Interpolation eines Bildes

[Sued_Faust]

Moin Leute,

ich habe die Aufgabe ein Bild (als JPEG), in java zu importieren und dann zu interpolieren und zwar von der Farbe schwarz ausgehend soll das Bild wieder sichtbar werden.
Das ganze soll dann aber so aussehen das ein Balken, z.B. ein Rectangle2D von links nach rechts über den Bildschirm wandert und dabei die interpolation hinter sich herzieht. Das soll dann den effekt haben das der Balken sozusagen ein SChmiereffekt hinter sich herzieht. D.h. also das die Interpolation nicht aufeinmal für das ganze Bilde berechnet werden soll, sondern immer etwas hinter dem Balken der sich von rechts nach links bewegt.

Ich habe es bis jetzt nur hinbekommen das ganze Bild zu interpolieren wird. Ich weiß nun nicht wie ich es hinbekomme das immer nur ein stück interpoliert wird und diese Interpolation dann auch noch einem Balken "folgt".

hier schon mal mein Quellcode:

package Online;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

public class Interpolation extends JFrame{
		
	public Graphics2D g2d;
	public Graphics2D g2d_1;
	
	private BufferedImage bild_Original;
	private BufferedImage bild_Schwarz;
	private BufferedImage bild_Temp;

	private int[] rechteck1 = new int[5];
	private int[] rechteck2 = new int[5];
	
	private int imageWidth; 
	private int imageHeight;

	public Interpolation(int width, int height) throws IOException {

		bild_Original = ImageIO.read(new File("Lenzburg.jpg"));
		bild_Schwarz = new BufferedImage(800,600,BufferedImage.TYPE_INT_RGB);
		bild_Temp = ImageIO.read(new File("Lenzburg.jpg"));

		this.setSize(new Dimension(width, height));
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setVisible(true);
		this.setResizable(false);
		this.setTitle("Interpolation");
	
		doInitialistion();		
	}
	
	public void doInitialistion(){	
		//Rechteck-Koordinaten
		rechteck1[1] = 2; 
		rechteck1[2] = 0;
		rechteck1[3] = 50;
		rechteck1[4] = 600;
		
		//Rechteck-Koordinaten
		rechteck2[1] = 799;
		rechteck2[2] = 0;
		rechteck2[3] = 50;
		rechteck2[4] = 599;
		
		imageWidth = bild_Original.getWidth();
		imageHeight = bild_Original.getHeight(); 
	}
	
	public void paint(Graphics g){
		update(g);
	}
	
	public void update(Graphics g){			
		g2d = (Graphics2D) g;
		
		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
			
		//g2d.drawImage(bild_Original, 0, 0, this);

		Rectangle2D.Double rect = new Rectangle2D.Double(rechteck1[1],rechteck1[2],rechteck1[3],rechteck1[4]);
		
		g2d.fill(rect);
		
		double x[] = new double[rechteck1.length];
		
		//Schrittanzahl
		int steps = 60;
		double stepsdouble = steps;
		
		Color color_Black;
		Color color_Original;
		Color color_temp;
		
		for (int k = 1; k < steps; k++) {
			double alpha = k/stepsdouble;
			
			for (int i = 1; i < 800; i++)
			{
				for (int j = 1; j < 600; j++)
				{
					color_Original = new Color(bild_Original.getRGB(i,j));
					color_Black = new Color(bild_Schwarz.getRGB(i, j));
					
					int rot  = (int) ((1-alpha) * color_Black.getRed()   + alpha * color_Original.getRed());
					int grün = (int) ((1-alpha) * color_Black.getGreen() + alpha * color_Original.getGreen());
					int blau = (int) ((1-alpha) * color_Black.getBlue()  + alpha * color_Original.getBlue());
					
					color_temp = new Color(rot,grün,blau);
					bild_Temp.setRGB(i,j,color_temp.getRGB());
				}	
			}
			g2d.drawImage(bild_Temp, 0, 0, this);

		}
	}

	public static void main(String[] args) throws IOException {
		new Interpolation(800,600);
	}

}

Ich hoffe das mir da vieleicht jemand auf die Sprünge helfen kann 🙂.

gruß

Patrick

 

[SlaterB]

nettes Programm,
zur Umsetzung deines Problems musst du den alpha-Faktor von der Position abhängig machen,
ein einfacher Umbau zu

		for (int k = 1; k < steps; k++) {

			for (int i = 1; i < imageWidth; i++) {
				double alpha = (k-i) / stepsdouble;
				alpha = Math.max(0, alpha);

an der Doppelschleife führt z.B. schon zu einem interessanten Effekt,
kannst von da aus weiterdenken

edit:
generell schöner: in einem JPanel zeichnen, paintComponent() überschreiben,
keine Schleife während des Zeichnens sondern eher separat einen Thread laufen lassen, der alle x ms repaint() aufruft

 

[0x7F800000]

zum einen ist nicht ganz einleuchtend, was du da meinst, zum anderen sind magic numbers ein sehr hässlicher antipattern: mit einem 400x300px bild hat dein programm bei mir nur noch exceptions geworfen, weil du in deinen code irgendwelche zahlen wie "800" und "600" hard reingecoded hast... :noe:

 

[Sued_Faust]

@SlaterB

Danke das ist schon mal ne Idee, ich habs einfach mal ausprobiert und vom rechten Rand aus fängt es auch schon wie gewünscht an. Bei mir kommt er aber nicht weiter als vieleicht 1/10 des bildes. Zudem soll auch der Rechte teil des Bildes zusehen sein es soll ja ein balken rüberfahren der vieleicht ne bereite von 50 px hat.

@0x7F800000

Sry das es noch paar macken gibt, aber ich muss mich bisl um gröbere dinge kümmern und hatte gehoft das ihr das erkennt, dass das Bild diese größe habne muss.

gruß

 

[SlaterB]

wie gesagt, weiterdenken darfst du schon,

wenn du 60 Steps hast und das Image 600 Pixel breit ist, dann muss sich der Balken mit einer Geschwindigkeit von 10 bewegen,
ein Balken bedeutet vielleicht, dass dort alpha 0 oder 1 ist, je nach Art der Berechnung, dann muss er nicht nur links abfallen bzw. steigen, sondern auch rechts,

hier noch ein Beispiel:
double alpha = Math.abs((i/5)-k) / stepsdouble;
alpha = Math.max(0, alpha);
alpha = Math.min(1, alpha);

aber da musst du nun wirklich selber ausprobieren, rechnen usw

 

[Sued_Faust]

Ok, ich denke ich habs gecheckt, ich danke dir vielmals 🙂!!!!

gruß

Patrick

 

[0x7F800000]

Sry das es noch paar macken gibt, aber ich muss mich bisl um gröbere dinge kümmern und hatte gehoft das ihr das erkennt, dass das Bild diese größe habne muss.

Es geht doch nicht darum wer da was erkennt, sondern darum dass du am ende aus deinem code an 50 Stellen irgendwelche Zahlen rauskratzen musst, und wenn du dich dabei einmal verrechnest oder vertippst, läuft erstmal wieder nichts mehr. Tust dir dadurch selbst keinen Gefallen. Aber gut, jetzt ist's egal, merk's einfach für später...