# diagramm verkleinern



## helft mir bitte (19. Jul 2006)

die rechte darstellung soll so groß sein wie die linke! einfach x und y werte /10 geht net weil dann kein integer mehr da ist!


```
/** Orientierungsprogramm.java
* Written by Paul Bertram from the 10th of July to the 14th of July, 2006
* based on the programm "Superpredator" by Jürgen Hubert
*ax-neu = ax-alt*cos(alpha)+ay-alt*sin(alpha)
*ay-neu = -ax-alt*sin(alpha)+ay-alt*cos(alpha)
*/
import java.awt.*;
import java.awt.color.*;
import java.awt.event.*;
import java.applet.*;
import java.math.*;
import java.util.*;

public class Orientierungsprogramm
extends Applet
implements ActionListener
{

TextField stepNrField;
TextField orientNrField;
TextField rateOrientField;
TextField abcField;
TextField festeWField;
TextField radiusField;

Random r = new Random();

double di= 0;

double p = 0; //Variablen werden erzeugt
double eAlt = 0;
double eNeu = 0;
double eDiff = 0;
double eAltb = 0;
double eNeub = 0;
double eDiffb = 0;
double b;
double l = Math.sqrt(2);
double festeW = 0;
double radius = 2;

int x,y;
int x_rel,y_rel;
int red, green, blue;
int q;
int w;
int ente;
int ergebnis;
int ergebnis2;

int xSize = 100;
int ySize = 100;
int xSizeb = 142;
int ySizeb = 142;

int a=4;

double[][] orient = new double [xSize][ySize];
double[][] orientNeu = new double[xSize][ySize];
double[][] orientSave = new double[xSize][ySize];

double[][] orientb = new double [xSizeb][ySizeb];
double[][] orientNeub = new double[xSizeb][ySizeb];
double[][] orientSaveb = new double[xSizeb][ySizeb];

int orientNr;

double stepNr;

int iterNr;

double rateOrient;

public void init() //initialize layout, calculate starting values
{
  setLayout(null);
  Button resetButton = new Button("Neu"); // erzeugt einen Button
  resetButton.setBounds(20,430,100,40);
  resetButton.addActionListener(this);
  add(resetButton);

  setLayout(null);
  Button calculateButton = new Button("Rechnen"); // erzeugt einen Button
  calculateButton.setBounds(130,430,100,40);
  calculateButton.addActionListener(this);
  add(calculateButton);

  stepNrField = new TextField("1"); // erzeugt ein Textfeld
  stepNrField.setBounds(100,480,100,40);
  add(stepNrField);

  orientNrField = new TextField("4"); // erzeugt ein Textfeld
  orientNrField.setBounds(340,530,100,40);
  add(orientNrField);

  rateOrientField = new TextField("1"); // erzeugt ein Textfeld
  rateOrientField.setBounds(100,530,100,40);
  add(rateOrientField);

  abcField = new TextField("0"); // erzeugt ein Textfeld
  abcField.setBounds(340,480,100,40);
  add(abcField);

  festeWField = new TextField("0");
  festeWField.setBounds(440,430,50,40);
  add(festeWField);

  radiusField = new TextField("1.5");
  radiusField.setBounds(300,640,100,40);
  add(radiusField);


  orientNr = Integer.parseInt(orientNrField.getText()); // weist orientNr einen Wert zu
  rateOrient = Double.parseDouble(rateOrientField.getText()); // weist rateOrient einen Wert zu
  festeW = Double.parseDouble(festeWField.getText()); // weist festeW einen Wert zu
  radius = Double.parseDouble(radiusField.getText()); // weist radius einen Wert zu


  ResetValues();
  repaint();
}

public void paint(Graphics g) //draw text and displays
{
  g.drawString("Wahrscheinlichkeitswert :",280,450);
  g.drawString("Schritte ;",10,510);
  g.drawString("Orientierungen :",220,550);
  g.drawString("O-wechsel :",10,550);
  g.drawString("Aktueller Schritt: " + iterNr,460,510);
  g.drawString("Zufallsstärke: ",220,510);
  g.drawString("Radius : ",10,640);
  
  orientb[141][70]=0.5;
  orientb[141][71]=0.6;
  orientb[71][0]=0.6;
  orientb[70][0]=0.5;
  orientb[0][70]=0.6;
  orientb[0][71]=0.5;    
  orientb[70][141]=0.6;
  orientb[71][141]=0.5; 
  
  for(x=0;x<xSize;x++) {                 // im folgendem werden den Orientierungen Farben zugewiesen
    for(y=0;y<ySize;y++) {
  
      if (orient[x][y] < 0.166666 ) {
        blue = 255;
        green = (int)((orient[x][y]*6.0)*255.0);
        red = 0;
      } 
      else if (orient[x][y] < 0.333334 ) {
        blue = (int)((((0.33333)-orient[x][y])*6.0)*255.0);
        green = 255;
        red = 0;
      }
      else if (orient[x][y] < 0.5 ) {
        blue = 0;
        green = 255;
        red = (int)(-((orient[x][y]-(0.5))*6.0)*255.0);
      }    
      else if (orient[x][y] < 0.66666 ) {
        blue = 0;
        green = (int)((((0.66666)-orient[x][y])*6.0)*255.0);
        red = 255;
      }      
      else if (orient[x][y] < 0.833334 ) {
        blue = (int)(-((orient[x][y]-(0.83333))*6.0)*255.0);
        green = 0;
        red = 255;
      }    
      else if (orient[x][y] <= 1.0) {
        blue = 255;
        green = 0;
        red = (int)(((1.0-orient[x][y])*6.0)*255.0);
      }
   
      g.setColor(new Color(red,green,blue));
      g.fillRect(x*a,y*a,a,a); // hier wird gemalt
    }
  }
  for(x=0;x<xSizeb;x++) {                 // im folgendem werden den Orientierungen Farben zugewiesen
    for(y=0;y<ySizeb;y++) {
     if(x!=80) ;
     else orientb[x][y]=0.55;
     if(y!=49) ;
     else orientb[x][y]=0.7;
     if(y!=51);
     else orientb[x][y]=0.4;
     if(y!=50) ;
     else orientb[x][y]=0.2;
      for(ente=0;ente<=71;ente++){
        ergebnis = (x-ente)+(y-ente);
        if(ergebnis!=70 && ergebnis!=71){
        }
        else{
          ergebnis2=x+y;
          if(ergebnis2!=213){
            if((x-ente)>=0 && (y-ente)>=0){
       
              if (orientb[x][y] < 0.166666 ) {
                blue = 255;
                green = (int)((orientb[x][y]*6.0)*255.0);
                red = 0;
              } 
              else if (orientb[x][y] < 0.333334 ) {
                blue = (int)((((0.33333)-orientb[x][y])*6.0)*255.0);
                green = 255;
                red = 0;
              }
              else if (orientb[x][y] < 0.5 ) {
                blue = 0;
                green = 255;
                red = (int)(-((orientb[x][y]-(0.5))*6.0)*255.0);
              }    
              else if (orientb[x][y] < 0.66666 ) {
                blue = 0;
                green = (int)((((0.66666)-orientb[x][y])*6.0)*255.0);
                red = 255;
              }      
              else if (orientb[x][y] < 0.833334 ) {
                blue = (int)(-((orientb[x][y]-(0.83333))*6.0)*255.0);
                green = 0;
                red = 255;
              }    
              else if (orientb[x][y] <= 1.0) {
                blue = 255;
                green = 0;
                red = (int)(((1.0-orientb[x][y])*6.0)*255.0);
              }
	      int xb = (int)(x*10*Math.cos(0.25*Math.PI)+y*10*Math.sin(0.25*Math.PI))*3;
	      int yb = (int)(-x*10*Math.sin(0.25*Math.PI)+y*10*Math.cos(0.25*Math.PI))*3;
              
	      g.setColor(new Color(red,green,blue));
	      g.fillRect(-1004+xb,1555+yb,10,10); // hier wird gemalt
	      g.fillRect(-994+xb,1555+yb,10,10);
	      g.fillRect(-1004+xb,1545+yb,10,10);
	      g.fillRect(-1014+xb,1555+yb,10,10);
	      g.fillRect(-1004+xb,1565+yb,10,10);
	      g.fillRect(-999+xb,1560+yb,10,10);
	      g.fillRect(-999+xb,1550+yb,10,10);
	      g.fillRect(-1009+xb,1550+yb,10,10);
	      g.fillRect(-1009+xb,1560+yb,10,10);
	      g.fillRect(-1019+xb,1558+yb,5,5);
	      g.fillRect(-984+xb,1558+yb,5,5);
	      g.fillRect(-1001+xb,1575+yb,5,5);
	      g.fillRect(-1001+xb,1540+yb,5,5);
	    }           
	  }
        }
      }
    }
  }
}

public void actionPerformed(ActionEvent event) //react to buttons
{
  int i;
  int x, y;
  boolean calculate, reset;

  calculate = event.getActionCommand().equals("Rechnen");
  reset = event.getActionCommand().equals("Neu");

  if(calculate) {
    rateOrient = Double.parseDouble(rateOrientField.getText());  // Variabeln werden eingelesene Werte zugewiesen
    stepNr = Integer.parseInt(stepNrField.getText());
    b = Double.parseDouble(abcField.getText());
    festeW = Double.parseDouble(festeWField.getText()); // weist festeW einen Wert zu
    radius = Double.parseDouble(radiusField.getText());

    iterNr +=stepNr;

    for(i=1;i<=stepNr;i++) {
      CalculateStep(); // es wird gerechnet 
    }
  repaint();
  }

  if(reset) {
    orientNr = Integer.parseInt(orientNrField.getText());
    rateOrient = Double.parseDouble(rateOrientField.getText());
    b = Double.parseDouble(abcField.getText());
    festeW = Double.parseDouble(festeWField.getText());
    radius = Double.parseDouble(radiusField.getText());

    ResetValues();
    repaint();
  }
}


void CalculateStep()
{
  int x, y;

  for(x=0;x<xSizeb;x++){
    for(y=0;y<ySizeb;y++){
      UpdateZelle(x,y);
    }
  }
  for(x=0;x<xSizeb;x++){
    for(y=0;y<ySizeb;y++){
      if(x<xSize && y<ySize) orient[x][y] = orientSave[x][y];
      orientb[x][y] = orientSaveb[x][y];
    }
  }
}


void UpdateZelle(int x, int y)
{
  eAlt=0;
  eNeu=0;
  int radi, w2, q2;
  radi = (int) Math.floor(radius);

  if(x<xSize){
    if(y<ySize){
      orientNeu[x][y] = Math.floor(GetRandom()*((double)orientNr))/((double)orientNr); // eine zufällige neue Orientierung wird gewählt

      for(q=x-radi;q<=x+radi;q++){
    
        q2 = q;
    
        if(q2<0) q2 += xSize;
        if(q2>=xSize) q2 -= xSize;
    
        for(w=y-radi;w<=y+radi;w++){
      
          w2 = w;
      
          if(w2<0) w2 += ySize;
          if(w2>=ySize) w2 -= ySize;
      
          if((q!=x) || (w!=y)) {
            di = Math.sqrt(Math.pow(Math.abs(q-x), 2)+Math.pow(Math.abs(w-y), 2)) ;
            if(di<=radius){
              eAlt = eAlt + (Math.abs(Math.sin((orient[q2][w2]-orient[x][y])*Math.PI)))/di ;
              eNeu = eNeu + (Math.abs(Math.sin((orient[q2][w2]-orientNeu[x][y])*Math.PI)))/di ;
            }
          }                          
        }
      }
      eDiff = eNeu - eAlt; //Berechnung der Energie-Differrenz

      p = rateOrient*(1-Math.pow(Math.E, eDiff)) + b*GetRandom2(); //Berechnung der Wahrscheinlichkeit, dass die Orientierung sich ändert

      if(festeW != 0) {
        if(p > festeW){
          orientSave[x][y] = orientNeu[x][y]; //Neue Orientierung
        }
        else orientSave[x][y] = orient[x][y]; //Alte Orientierung
      }
      else {
        if(p > GetRandom()) { 
          orientSave[x][y] = orientNeu[x][y]; //Neue Orientierung
        }
        else orientSave[x][y] = orient[x][y]; //Alte Orientierung
      }
    }
  }
    // Feld B
  /*
  
  eAltb=0;
  eNeub=0;
  w2=0;
  q2=0;
  radi = (int) Math.floor(radius);

  orientNeub[x][y] = Math.floor(GetRandom()*((double)orientNr))/((double)orientNr); // eine zufällige neue Orientierung wird gewählt

  for(q=x-radi;q<=x+radi;q++){
    
    q2 = q;
    
    if(q2<0) q2 += xSizeb;
    if(q2>=xSizeb) q2 -= xSizeb;
    
    for(w=y-radi;w<=y+radi;w++){
      
      w2 = w;
      
      if(w2<0) w2 += ySizeb;
      if(w2>=ySizeb) w2 -= ySizeb;
      
      if((q!=x) || (w!=y)) {
        di = Math.sqrt(Math.pow(Math.abs(q-x), 2)+Math.pow(Math.abs(w-y), 2)) ;
        if(di<=radius){
          eAltb = eAltb + (Math.abs(Math.sin((orient[q2][w2]-orient[x][y])*Math.PI)))/di ;
          eNeub = eNeub + (Math.abs(Math.sin((orient[q2][w2]-orientNeu[x][y])*Math.PI)))/di ;
        }
      }                          
    }
  }
  eDiffb = eNeub - eAltb; //Berechnung der Energie-Differrenz

  p = rateOrient*(1-Math.pow(Math.E, eDiff)) + b*GetRandom2(); //Berechnung der Wahrscheinlichkeit, dass die Orientierung sich ändert

  if(festeW != 0) {
    if(p > festeW){
    orientSaveb[x][y] = orientNeub[x][y]; //Neue Orientierung
    }
    else orientSaveb[x][y] = orientb[x][y]; //Alte Orientierung
  }
  else {
    if(p > GetRandom()) { 
      orientSaveb[x][y] = orientNeub[x][y]; //Neue Orientierung
    }
    else orientSaveb[x][y] = orientb[x][y]; //Alte Orientierung
  }
*/ 
}




void ResetValues()
{
  int x, y;

  iterNr = 0;

  for(x=0;x<xSize;x++) {
    for(y=0;y<ySize;y++) {
  
      orient[x][y] = Math.floor(GetRandom()*((double)orientNr))/((double)orientNr); //den Zellen werden
      // Orientierungen zugewiesen

    }
  }
  for(x=0;x<xSizeb;x++) {
    for(y=0;y<ySizeb;y++) {
      for(ente=0;ente<=71;ente++){
        ergebnis = (x-ente)+(y-ente);
        if(ergebnis!=70 && ergebnis!=71){
        }
        else{
          ergebnis2=x+y;
          if(ergebnis2!=213){
            if((x-ente)>=0 && (y-ente)>=0){     
              orientb[x][y] = Math.floor(GetRandom()*((double)orientNr))/((double)orientNr); //den Zellen werden
              // Orientierungen zugewiesen
            }
          }
        }
      }
    }
  }
}

double GetRandom()
{
  double ranVal = Math.abs(Math.random());
  return ranVal - Math.floor(ranVal);        // Eine Zahl zwischen 0 und 1 wird ausgewürfelt
}

double GetRandom2()
{
  return GetRandom()*2-1;      // Eine Zahl zwischen -1 und 1 wird ausgewürfelt
}

}
```


----------



## Gast (19. Jul 2006)

Ja kennt sich hier denn keiner mit antialiasing aus?


----------



## Leroy42 (21. Jul 2006)

Gast hat gesagt.:
			
		

> Ja kennt sich hier denn keiner mit antialiasing aus?



Sicher doch! Aber 


			
				helft mir bitte hat gesagt.:
			
		

> die rechte darstellung soll so groß sein wie die linke! einfach x und y werte /10 geht net weil dann kein integer mehr da ist!


bei einer solch dürftigen, unverständlichen und noch
dazu unsinnigen Problembeschreibung (wieso sind _dann keine Integer mehr da_? Wo 
sind die denn alle hin  :shock: )
hat wohl kaum jemand Lust, sich durch diesen 460-Zeilen code zu wühlen.


----------

