class Grid
{
  //PROPERTIES
  int pointsX;
  int pointsY;
  float distX;
  float distY;
  Image gridImg;
  int averageBrightness;
  ArrayList gridX = new ArrayList();
  Config conf;
  float moveSize;
  
  //CONSTRUCTOR
  Grid(int cPointsX, int cPointsY, float cDistX, float cDistY, int imageNr)
  {
    conf = new Config();
    this.pointsX = cPointsX;
    this.pointsY = cPointsY;
    this.distX = cDistX;
    this.distY = cDistY;
    this.gridImg = new Image(this.getWidth(), this.getHeight(), imageNr);
    this.moveSize = this.conf.moveSize;
    
    for (int i = 0; i < this.pointsX; i++)
    {
      ArrayList gridY = new ArrayList();
      for (int m = 0; m < this.pointsY; m++)
      {
        Point cPoint = new Point(i * distX, m * distY, 0);
        gridY.add(cPoint);
      }
      this.gridX.add(gridY);
    }
  }
  
  void changeImage(int number)
  {
    this.gridImg.change(number);
  }
  
  void addCol()
  {
    //println("hallo");
    ArrayList gridY1 = new ArrayList();
    ArrayList gridY2 = new ArrayList();
    for (int m = 0; m < this.pointsY; m++)
    {
      Point point1 = new Point(pointsX * this.distX, m * this.distY, 0);
      gridY1.add(point1);
      Point point2 = new Point((pointsX + 1) * this.distX, m * this.distY, 0);
      gridY2.add(point2);
    }
    this.gridX.add(gridY1);
    this.gridX.add(gridY2);
    this.pointsX += 2;
    
    this.gridImg.changeDimensions(this.getWidth(), this.getHeight());
  }
  
  void removeCol()
  {
    this.gridX.remove(pointsX - 1);
    this.gridX.remove(pointsX - 2);
    this.pointsX -= 2;
    
    this.gridImg.changeDimensions(this.getWidth(), this.getHeight());
  }
  
  
  
  void addLine()
  {
    //println("hallo");
    for (int m = 0; m < this.pointsX; m++)
    {
      ArrayList gridY = (ArrayList) gridX.get(m);
      
      Point point1 = new Point(m * distX, pointsY * distY, 0);
      gridY.add(point1);
      Point point2 = new Point(m * distX, (pointsY + 1) * distY, 0);
      gridY.add(point2);
      this.gridX.set(m, gridY);
    }
    this.pointsY += 2;
    
    this.gridImg.changeDimensions(this.getWidth(), this.getHeight());
  }
  
  void removeLine()
  {
    for (int m = 0; m < this.pointsX; m++)
    {
      ArrayList gridY = (ArrayList) this.gridX.get(m);
     
      gridY.remove(pointsY - 1);
      gridY.remove(pointsY - 2);
      this.gridX.set(m, gridY);
    }
    this.pointsY -= 2;
    
    this.gridImg.changeDimensions(this.getWidth(), this.getHeight());
  }
  
  
  float getRatio()
  {
    float width1 = this.getWidth();
    float height1 = this.getHeight();
    float width2 = width;
    float height2 = height;
    
    float ratio1 = width2 / width1;
    float ratio2 = height2 / height1;
    
    if (width1 * ratio2 >= width2)
    {
      return ratio1;
    }
    else if (height1 * ratio1 > height2)
    {
      return ratio2;
    }
    return 0.0;
  }
  
  void drawYourself(int on)
  {
    
    if (on == 1)
    {
      gridImg.drawYourself(this.getRatio());
    }
    
    for (int i = 0; i < this.pointsX; i++)
    {
      ArrayList gridY = (ArrayList) gridX.get(i);
      for (int m = 0; m < this.pointsY; m++)
      {
        Point cPoint = (Point) gridY.get(m);
        //println("x:" + cPoint.getX());
        //println("y:" + cPoint.getY());
        //cPoint.drawYourself(this.getRatio());
      }
    }
    
    //odd

    for (int i = 0; i < (this.pointsX - 1); i += 2)
    {
      for (int m = 0; m < (this.pointsY - 1); m += 2)
      {
        ArrayList gridY1 = (ArrayList) this.gridX.get(i);
        ArrayList gridY2 = (ArrayList) this.gridX.get(i + 1);
        ArrayList gridY3 = (ArrayList) this.gridX.get(i + 2);
        Point point1 = (Point) gridY1.get(m + 1);
        Point point2 = (Point) gridY2.get(m);
        Point point3 = (Point) gridY3.get(m + 1);
        Point point4 = (Point) gridY2.get(m + 2);
        
        Point midPoint = getMidPoint(point1, point2, point3, point4);
        float elevation = this.getElevation(midPoint);
        
        Window window = new Window(point1, point2, point3, point4, elevation);
        if (window.getSmallestAngle() < PI / 180)
        {
          this.elasticMinus();
        }
        window.drawYourself(this.getRatio());
      }
    }

    
    
    //even
    for (int i = 1; i < (this.pointsX - 2); i += 2)
    {
      for (int m = 1; m < (this.pointsY - 2); m += 2)
      {
        ArrayList gridY1 = (ArrayList) this.gridX.get(i);
        ArrayList gridY2 = (ArrayList) this.gridX.get(i + 1);
        ArrayList gridY3 = (ArrayList) this.gridX.get(i + 2);
        Point point1 = (Point) gridY1.get(m + 1);
        Point point2 = (Point) gridY2.get(m);
        Point point3 = (Point) gridY3.get(m + 1);
        Point point4 = (Point) gridY2.get(m + 2);
        
        Point midPoint = getMidPoint(point1, point2, point3, point4);
        float elevation = this.getElevation(midPoint);
        
        Window window = new Window(point1, point2, point3, point4, elevation);
        if (window.getSmallestAngle() < PI / 8)
        {
          this.elasticMinus();
        }
        window.drawYourself(this.getRatio());
      }
    }
    
  }
  
  float getTotalBrightHor(int index)
  {
    float totalBright = 0;
    for (int i = 0; i < this.pointsX - 1; i++)
    {
      ArrayList gridY1 = (ArrayList) gridX.get(i);
      ArrayList gridY2 = (ArrayList) gridX.get(i + 1);
      Point point1 = (Point) gridY1.get(index);
      Point point2 = (Point) gridY2.get(index);
      Point midPoint = this.getMidPoint(point1, point2);
      totalBright += this.gridImg.getBrightnessDamp(midPoint);
    }
    return totalBright;
  }
  
  float getTotalBrightVer(int index)
  {
    float totalBright = 0;
    for (int i = 0; i < this.pointsY - 1; i++)
    {
      ArrayList gridY = (ArrayList) gridX.get(index);
      Point point1 = (Point) gridY.get(i);
      Point point2 = (Point) gridY.get(i + 1);
      Point midPoint = this.getMidPoint(point1, point2);
      totalBright += this.gridImg.getBrightnessDamp(midPoint);
    }
    return totalBright;
  }
  float getElevation(Point cPoint)
  {
    return map(this.gridImg.getBrightness(cPoint), 0, 255, this.conf.elevationMin, this.conf.elevationMax);
  }
  
  float getDistanceX(Point point1, Point point2)
  {
    return point2.getX() - point1.getX();
  }
  
  float getDistanceY(Point point1, Point point2)
  {
    return point2.getY() - point1.getY();
  }
  
  void movePoints()
  {
    //println("pointsY:" + this.pointsY);
    //println("pointsX:" + this.pointsX);
    
    
    //vertical
    
    
    for (int i = 0; i < this.pointsX; i++)
    {
      ArrayList gridY = (ArrayList) gridX.get(i);
      for (int m = 0; m < this.pointsY - 1; m++)
      {
        Point point1 = (Point) gridY.get(m);
        Point point2 = (Point) gridY.get(m + 1);
        Point midPoint = this.getMidPoint(point1, point2);
        
        //wenn der abstand groesser ist als die helligkeit des dazwischen liegenden pixels im verhaeltnis zur durchschnittlichen helligkeiten in der kolonne
        if (this.getDistanceY(point1, point2) > (this.gridImg.getBrightnessDamp(midPoint) / this.getTotalBrightVer(i)) * this.getHeight())
        {
          
          //println("contract");
          //contract
          //gridY.set(m, new Point(point1.getX(), point1.getY() + this.conf.moveSize));
          gridY.set(m + 1, new Point(point2.getX(), point2.getY() - this.moveSize, 0));
        }
        //wenn der abstand kleiner ist
        else if (this.getDistanceY(point1, point2) < (this.gridImg.getBrightnessDamp(midPoint) / this.getTotalBrightVer(i)) * this.getHeight())
        {
          
          //println("contract");
          //expand
          //gridY.set(m, new Point(point1.getX(), point1.getY() - this.conf.moveSize));
          gridY.set(m + 1, new Point(point2.getX(), point2.getY() + this.moveSize, 0));
        }
      }
      this.gridX.set(i, gridY);
    }
   
    

    //horizontal
    
    for (int m = 0; m < this.pointsX - 1; m++)
    {
      ArrayList gridY1 = (ArrayList) this.gridX.get(m);
      ArrayList gridY2 = (ArrayList) this.gridX.get(m + 1);
      
      for (int i = 0; i < this.pointsY; i++)
      {
        
        Point point1 = (Point) gridY1.get(i);
        Point point2 = (Point) gridY2.get(i);
        Point midPoint = this.getMidPoint(point1, point2);
        //wenn der abstand groesser ist als die helligkeit des dazwischen liegenden pixels im verhaeltnis zur durchschnittlichen helligkeiten in der linie
        if (this.getDistanceX(point1, point2) < (this.gridImg.getBrightnessDamp(midPoint) / this.getTotalBrightHor(i)) * this.getWidth())
        {
          
          //expand
          //gridY1.set(i, new Point(point1.getX() - conf.moveSize, point1.getY()));
          gridY2.set(i, new Point(point2.getX() + this.moveSize, point2.getY(), 0));
          
        }
        //wenn der abstand kleiner ist
        else if (this.getDistanceX(point1, point2) > (this.gridImg.getBrightnessDamp(midPoint) / this.getTotalBrightHor(i)) * this.getWidth())
        {
          
          //contract
          //gridY1.set(i, new Point(point1.getX() + conf.moveSize, point1.getY()));
          gridY2.set(i, new Point(point2.getX() - this.moveSize, point2.getY(), 0));
          
        }
      }
      this.gridX.set(m, gridY1);
      this.gridX.set(m + 1, gridY2);
    }
    

    
    
    
    //reset edge points
    
    for (int i = 0; i < this.pointsX; i++)
    {
      ArrayList gridY = (ArrayList) this.gridX.get(i);
      
      for (int m = 0; m < this.pointsY; m++)
      {
        Point cPoint = (Point) gridY.get(m);
        
        if (cPoint.getX() < 0)
        {
          cPoint.setPosition(0, cPoint.getY(), 0);
        }
        if (cPoint.getX() > this.getWidth())
        {
          cPoint.setPosition(this.getWidth(), cPoint.getY(), 0);
        }
        if (cPoint.getY() < 0)
        {
          cPoint.setPosition(cPoint.getX(), 0, 0);
        }
        if (cPoint.getY() > this.getHeight())
        {
          cPoint.setPosition(cPoint.getX(), this.getHeight(), 0);
        }
        gridY.set(m, cPoint);
      }
      gridX.set(i, gridY);
    }
  
    //horizontal
    for (int i = 0; i < this.pointsX; i++)
    {
      ArrayList gridY = (ArrayList) this.gridX.get(i);
      // top edge
      Point cPoint = (Point) gridY.get(0);
      cPoint.setPosition(cPoint.getX(), 0, 0);
      gridY.set(0, cPoint);
      
      //bottom edge
      cPoint = (Point) gridY.get(this.pointsY - 1);
      cPoint.setPosition(cPoint.getX(), this.getHeight(), 0);
      gridY.set(this.pointsY - 1, cPoint);
    }

    

    //vertical
    ArrayList gridY1 = (ArrayList) this.gridX.get(0);
    ArrayList gridY2 = (ArrayList) this.gridX.get(this.pointsX - 1);
    for (int i = 0; i < this.pointsY; i++)
    {
      
      Point point1 = (Point) gridY1.get(i);
      Point point2 = (Point) gridY2.get(i);
      point1.setPosition(0, point1.getY(), 0);
      point2.setPosition(this.getWidth(), point2.getY(), 0);
      gridY1.set(i, point1);
      gridY2.set(i, point2);
    }
    this.gridX.set(0, gridY1);
    this.gridX.set(this.pointsX - 1, gridY2);
 
    
  }
  
  Point getMidPoint(Point point1, Point point2)
  {
    Point cPoint = new Point((point2.getX() - point1.getX()) / 2 + point1.getX(), (point2.getY() - point1.getY()) / 2 + point1.getY(), (point2.getZ() - point1.getZ()) / 2 + point1.getZ());
    return cPoint;
  }
  
  Point getMidPoint(Point point1, Point point2, Point point3, Point point4)
  {
    Point midPoint1 = getMidPoint(point1, point3);
    Point midPoint2 = getMidPoint(point2, point4);
    return getMidPoint(midPoint1, midPoint2);
  }
  
  float getWidth()
  {
    return this.distX * (this.pointsX - 1);
  }
  float getHeight()
  {
    return this.distY * (this.pointsY - 1);
  }
  void elasticPlus()
  {
    this.gridImg.elasticPlus();
  }
  void elasticMinus()
  {
    this.gridImg.elasticMinus();
  }
  void speedUp()
  {
    this.moveSize += 0.1;
    println("Speed: " + this.moveSize);
  }
  void speedDown()
  {
    this.moveSize -= 0.1;
    println("Speed: " + this.moveSize);
  }
}