Einfache Bildverarbeitungsalgorithmus verursacht Verarbeitung einzufrieren

Question

ich einen Algorithmus in Verarbeitung geschrieben habe folgendes zu tun: sofort

1. Instantiate a 94 x 2 int array 
2. Load a jpg image of dimensions 500 x 500 pixels 
3. Iterate over every pixel in the image and determine whether it is black or white then change a variable related to the array 
4. Print the contents of the array 

Aus irgendeinem Grund dieser Algorithmus gefriert. Ich habe print-Anweisungen eingebaut, die zeigen, dass es erstarrt, bevor man versucht, das Bild zu laden. Dies ist besonders verwirrend für mich, da ich einen anderen sehr ähnlichen Algorithmus geschrieben habe, der ohne Komplikationen ausgeführt werden kann. Der andere Algorithmus liest ein Bild, mittelt die Farbe jeder Kachel mit der angegebenen Größe und druckt anschließend Rechtecke über der Region, die mit der Durchschnittsfarbe gemittelt wurde, wodurch das Bild effektiv pixeliert wird. Beide Algorithmen laden ein Bild und untersuchen jedes seiner Pixel. Die eine Frage ist meistens anders, weil sie nichts zeichnet. Ich würde sagen, dass es für ein Array anders ist, aber der Pixelierungsalgorithmus enthält alle Farben in einem Farbarray, das viel mehr Platz einnehmen sollte als das int-Array.

Aus dem Blick in meine Konsole console.app sehe ich, dass es ursprünglich diesen Fehler gab: "java.lang.OutOfMemoryError: GC Overhead-Limit überschritten". Von anderen Vorschlägen/Quellen im Web habe ich versucht, die Speicherzuweisung von 256 MB auf 4000 MB zu stoßen (dies fühlte sich bedeutungslos an, weil meine Analyse der Algorithmen zeigte, dass sie die gleiche Komplexität haben sollten, aber ich versuchte es trotzdem). Dies hörte nicht mit dem Einfrieren auf, sondern änderte den Fehler in eine Kombination von "JavaNativeFoundation-Fehler beim Abrufen der Java-Ausnahmebeschreibung" und "java.lang.OutOfMemoryError: Java-Heap-Space". Dann versuchte ich, die Verarbeitung zu meinem lokalen jdk mit der Hoffnung der Verwendung der 64-Bit-jdk über Verarbeitung eingebauten 32-Bit-jdk. Von innerhalb von Processing.app/Contents habe ich folgende Befehle ausgeführt: mv Java java-alt ln -s /Library/Java/JavaVirtualMachines/jdk1.7.0_79.jdk Java Die Verarbeitung würde nicht nach diesem Versuch mit dem folgenden Fehler auffüllen beginnen meine Konsole: "com.apple.xpc.launchd [1]: (org.processing.app.160672 [13559]) Service mit abnormen Code verlassen: 1"

Unten ist mein Code: Zuerst wird der nicht kompatiblen Algorithmus

int squareSize=50; 
int numRows = 10; 
int numCols = 10; 
PFont myFont; 
PImage img; 

//33-126 
void setup(){ 
    size(500,500); 
    count(); 
} 

void count(){ 
    ellipseMode(RADIUS); 
    int[][] asciiArea = new int[94][2]; 
    println("hello?"); 
    img=loadImage("countingPicture.jpg"); 
    println("image loaded"); 
    for(int i=0; i<(500/squareSize); i++){ 
    for(int j=0; j<(500/squareSize); j++){ 
     int currentValue=i+j*numCols; 
     if(currentValue+33>126){ 
     break; 
     } 
     println(i+", "+j); 
     asciiArea[currentValue][0]=currentValue+33; 
     asciiArea[currentValue][1]=determineTextArea(i,j,squareSize); 
     //fill(color(255,0,0)); 
     //ellipse(i*squareSize,j*squareSize,3,3); 
    } 
    } 
    println("done calculating"); 
    displayArrayContents(asciiArea); 
} 

int determineTextArea(int i, int j, int squareSize){ 
    int textArea = 0; 
    double n=0.0; 
    while(n < squareSize*squareSize){ 
    n+=1.0; 
    int xOffset = (int)(n%((double)squareSize)); 
    int yOffset = (int)(n/((double)squareSize)); 
    color c = img.get(i*squareSize+xOffset, j*squareSize+yOffset); 
    if(red(c)!=255 || green(c)!=255 || blue(c)!=255){ 
     println(red(c)+" "+green(c)+" "+blue(c)); 
     textArea++;   
    }  
    } 
    return textArea; 
} 

void displayArrayContents(int[][] arr){ 
    int i=0; 
    println("\n now arrays"); 
    while(i<94){ 
    println(arr[i][0]+" "+arr[i][1]); 
    } 
} 

Der pixelation Algorithmus, der funktioniert:

PImage img; 
int direction = 1; 
float signal; 
int squareSize = 5; 
int wideness = 500; 
int highness = 420; 
int xDimension = wideness/squareSize; 
int yDimension= highness/squareSize; 

void setup() { 
    size(1500, 420); 
    noFill(); 
    stroke(255); 
    frameRate(30); 
    img = loadImage("imageIn.jpg"); 
    color[][] colors = new color[xDimension][yDimension]; 
    for(int drawingNo=0; drawingNo < 3; drawingNo++){ 
    for(int i=0; i<xDimension; i++){ 
    for(int j=0; j<yDimension; j++){ 
     double average = 0; 
     double n=0.0; 
     while(n < squareSize*squareSize){ 
     n+=1.0; 
     int xOffset = (int)(n%((double)squareSize)); 
     int yOffset = (int)(n/((double)squareSize)); 
     color c = img.get(i*squareSize+xOffset, j*squareSize+yOffset); 
     float cube = red(c)*red(c) + green(c)*green(c) + blue(c)*blue(c); 
     double grayValue = (int)(sqrt(cube)*(255.0/441.0)); 
     double nAsDouble = (double)n; 
     average=(grayValue + (n-1.0)*average)/n; 
     average=(grayValue/n)+((n-1.0)/(n))*average; 
     } 
     //average=discretize(average); 
     println(i+" "+j+" "+average); 
     colors[i][j]=color((int)average); 
     fill(colors[i][j]); 
     if(drawingNo==0){ //stroke(colors[i][j]); } 
     stroke(210);} 
     if(drawingNo==1){ stroke(150); } 
     if(drawingNo==2){ stroke(90); } 
     //stroke(colors[i][j]); 
     rect(drawingNo*wideness+i*squareSize,j*squareSize,squareSize,squareSize); 
    } 
    } 
    } 
    save("imageOut.jpg"); 
} 

Answer 1

Sie betreten eine Endlosschleife, die die println()-Anweisungen unzuverlässig macht. Korrigieren Sie die Endlosschleife und Ihre Druckanweisungen funktionieren wieder.

Schauen Sie sich das while Schleife:

while(i<94){ 
    println(arr[i][0]+" "+arr[i][1]); 
} 

Wann wird i jemals >= 94 werden?

Sie erhöhen nie i, so ist sein Wert immer 0. Sie können dies unter Beweis stellen, indem eine println() Anweisung innerhalb der Schleife while Zugabe:

while(i<94){ 
    println("i: " + i); 
    println(arr[i][0]+" "+arr[i][1]); 
} 

Sie wahrscheinlich i innerhalb der while Schleife erhöhen wollte. Oder verwenden Sie einfach eine for Schleife.