---

Stats2File.java

gehe zur Dokumentation dieser Datei

/*
 * $Source: /shared/cvsroot/diplom/app/src/java/de/picana/converter/Stats2File.java,v $
 * $Author: mstolpe $
 * $Date: 2003/04/22 09:51:28 $
 * $Revision: 1.3 $
 * $Release$
 *
 * Created on 27. Februar 2003, 19:46
 * 
 * Copyright 2002 by Marco Stolpe 
 */

package de.picana.converter;

import de.picana.control.*;
import de.picana.logging.*;
import de.picana.clusterer.*;

import org.apache.velocity.VelocityContext;
import org.apache.velocity.Template;
import org.apache.velocity.app.VelocityEngine;

import weka.core.*;

import java.util.*;
import java.io.*;
import java.text.*;


public class Stats2File extends Task {
    
    private String statfile;
    private String modelfile;
    private String centroidfile;
    private String trainingfile;
    private String templatefile;
    private String resultfile;
    private ParameterSet context_set;
    
    private VectorFreqList model;
    private VectorFreqList centroids;
    
    
    public class VectorFreqList {
        
        private Vector set;
        private Hashtable attributes;
        
        public VectorFreqList() {
            this.set = new Vector();
            attributes = new Hashtable();
        }
        
        public void addVector(MLVector vec) {
            this.set.addElement(vec);
        }
        
        public void addAttribute(String att) {
            attributes.put(att, new Integer(attributes.size()));
        }
        
        public double value(int inst, int att) {
            return ((MLVector)set.elementAt(inst)).value[att];
        }
        
        public String value(int inst, String att) {
            Integer a = (Integer)attributes.get(att);
            return String.valueOf(((MLVector)set.elementAt(inst)).value[a.intValue()]);
        }
        
        public int freq(int inst) {
            return ((MLVector)set.elementAt(inst)).freq;    
        }
        
        public Enumeration attributes() {
            return attributes.keys();    
        }
        
        public int numAttributes() {
            return attributes.size();    
        }
        
        public int numVectors() {
            return set.size();    
        }
    }
    
    
    public class Functions {
    
        private DecimalFormat decf;
        
        public Functions() {
            decf = (DecimalFormat)DecimalFormat.getInstance(Locale.ENGLISH);
            decf.applyPattern("####0.000000");
        }
        
        public String decf(String value) {
            double d = 0.0;
            try {
                d = Double.parseDouble(value);
            } catch (NumberFormatException nfe) {}
            return decf.format(d);
        }
        
        public String getDateTimeString() {
            return Logger.getDateTimeString();    
        }
        
        public String getTimeString(String time) {
            long l = 0;
            try {
                l = Long.parseLong(time);
            } catch (NumberFormatException nfe) {}
            return Task.getTimeString(l);
        }
        
        public String getFilename(String path) {
            return (new File(path)).getName();    
        }
        
        public String getPath(String path) {
            String cp = "";
            try {
                cp = (new File(path)).getCanonicalPath().replace('\\','/');
            } catch (IOException io) {}
            return cp;    
        }
        
        public String getColor(String x, String y, String z) {
            int red = 0, green = 0, blue = 0;
            try {
                red = (int)(Double.parseDouble(x) * 255);
                green = (int)(Double.parseDouble(y) * 255);
                blue = (int)(Double.parseDouble(z) * 255);
            } catch (NumberFormatException nfe) {};
            String hexRed = Integer.toHexString(red);
            if (hexRed.length() == 1) hexRed = "0" + hexRed;
            String hexGreen = Integer.toHexString(green);
            if (hexGreen.length() == 1) hexGreen = "0" + hexGreen;
            String hexBlue = Integer.toHexString(blue);
            if (hexBlue.length() == 1) hexBlue = "0" + hexBlue;
            return "#" + hexRed + hexGreen + hexBlue;
        }
        
        public String getX(String x, String y, String z) {
            double dx = 0.0, dy = 0.0, dz = 0.0;
            try {
                dx = Double.parseDouble(x);
                dy = Double.parseDouble(y);
                dz = 1.0 - Double.parseDouble(z);
            } catch (NumberFormatException nfe) {};
            return String.valueOf(50 + Math.round(300 * (dx + 0.5 * dz * Math.cos(0.5235988))));
        }
        
        public String getY(String x, String y, String z) {
            double dx = 0.0, dy = 0.0, dz = 0.0;
            try {
                dx = Double.parseDouble(x);
                dy = Double.parseDouble(y);
                dz = 1.0 - Double.parseDouble(z);
            } catch (NumberFormatException nfe) {};
            return String.valueOf(425 - Math.round(300 * (dy + 0.5 * dz * Math.sin(0.5235988))));
        }
        
        public String getColor(String value) {
            double v = 0.0;
            try {
                v = Double.parseDouble(value);
            } catch (NumberFormatException nfe) {};
            return String.valueOf(Math.round(v * 255));
        }
    }
    
    
      
    public Stats2File() {
    }
    
    public void init(ParameterSet params, Logger logger) {
        
        super.init(params, logger);
    
        statfile = (String)params.getParameter("statistics");
        modelfile = (String)params.getParameter("model");
        centroidfile = (String)params.getParameter("centroids");
        templatefile = (String)params.getParameter("template");
        resultfile = (String)params.getParameter("out");
        context_set = (ParameterSet)params.getParameter("context");
    }
    
    public void start() throws TaskException {
        
        try {
            String resourcePath = (new File(templatefile)).getParentFile().getCanonicalPath();
            String resourceFile = (new File(templatefile)).getName();
        
            Properties p = new Properties();
            p.setProperty("file.resource.loader.path", resourcePath);
        
            VelocityEngine ve = new VelocityEngine();
            ve.init(p);

            VelocityContext context = new VelocityContext();
            
            // F?ge Statistiken in den Context ein
            
            if (statfile != null) {
                
                BufferedReader reader = new BufferedReader(new FileReader(new File(statfile)));
        
                String line;
                while ((line = reader.readLine()) != null) {
                    String key = line.substring(0, line.indexOf(":"));
                    String value = line.substring(line.indexOf(":")+1, line.length());
                    context.put(key, value);
                }
            }
            
            // F?ge Instanzen aus dem Modell (Startwerte) in den Context ein
            // (nur bei Clusterverfahren, die Startwerte berechnen!)
            
            if (modelfile != null) {
                
                model = new VectorFreqList();
                
                BufferedReader in = new BufferedReader(new FileReader(new File(modelfile)));
                String line = in.readLine();
                StringTokenizer tok = new StringTokenizer(line, ",");
                while (tok.hasMoreTokens()) {
                    model.addAttribute((String)tok.nextToken());    
                }
                
                while((line = in.readLine()) != null) {
                    tok = new StringTokenizer(line, ",");
                    MLVector vec = new MLVector(model.numAttributes());
                    int j=0;
                    while (tok.hasMoreTokens()) {
                        double d = 0.0;
                        String token = tok.nextToken();
                        try {
                            d = Double.parseDouble(token);
                        } catch (NumberFormatException nfe) {}
                        vec.value[j] = d;
                        j++;
                    }
                    vec.freq = 1;
                    model.addVector(vec);
                }
            
                in.close();
                
                context.put("model", model);
            }
            
            // F?ge die Zentroide zusammen mit den Cluster-Gr??en in den Context ein
            
            if (centroidfile != null) {
                
                centroids = new VectorFreqList();
                
                BufferedReader in = new BufferedReader(new FileReader(new File(centroidfile)));
                String line = in.readLine();
                line = in.readLine();
                String vector = line.substring(0, line.indexOf(":"));
                StringTokenizer tok = new StringTokenizer(vector, ",");
                while (tok.hasMoreTokens()) {
                    centroids.addAttribute((String)tok.nextToken());    
                }
                
                while((line = in.readLine()) != null) {
                    vector = line.substring(0, line.indexOf(":"));
                    String f = line.substring(line.indexOf(":")+1, line.length());
                    int freq = 0;
                    try {
                        freq = Integer.parseInt(f);
                    } catch (NumberFormatException nfe) {}
                    
                    tok = new StringTokenizer(vector, ",");
                    MLVector vec = new MLVector(centroids.numAttributes());
                    int j=0;
                    while (tok.hasMoreTokens()) {
                        double d = 0.0;
                        String token = tok.nextToken();
                        try {
                            d = Double.parseDouble(token);
                        } catch (NumberFormatException nfe) {}
                        vec.value[j] = d;
                        j++;
                    }
                    vec.freq = freq;
                    centroids.addVector(vec);
                }
            
                in.close();
                
                context.put("centroids", centroids);
            }
            
            // F?ge zus?tzliche Kontext-Variable ein
            
            if (context_set != null) {
                
                Enumeration e = context_set.getParameterNames();
                while (e.hasMoreElements()) {
                    String key = (String)e.nextElement();
                    context.put(key, (String)context_set.getParameter(key));
                }
            }
            
            context.put("func", new Functions());
            
            Template template = ve.getTemplate(resourceFile);

            PrintWriter pw = new PrintWriter(new FileOutputStream(new File(resultfile)));

            template.merge( context, pw );

            pw.close();
            
        } catch (Exception ex) {
            throw new TaskException(ex.toString());    
        }
    }
    
    public void stop() {
        
    }
    
    public void pause() {
        
    }
    
    public void resume() {
        
    }
}

---