TrakEM2_/src/main/java/mpi/fruitfly/general/ImageArrayConverter.java

   1 package mpi.fruitfly.general;
   2
   3 /**
   4  * <p>Title: </p>
   5  *
   6  * <p>Description: </p>
   7  *
   8  * <p>Copyright: Copyright (c) 2006</p>
   9  *
  10  * <p>Company: </p>
  11  *
  12  * @author not attributable
  13  * @version 1.0
  14  */
  15
  16 import static mpi.fruitfly.math.General.max;
  17 import ij.IJ;
  18 import ij.ImagePlus;
  19 import ij.ImageStack;
  20 import ij.process.ByteProcessor;
  21 import ij.process.FloatProcessor;
  22 import ij.process.ImageProcessor;
  23 import ij.process.ShortProcessor;
  24
  25 import java.awt.Point;
  26
  27 import mpi.fruitfly.math.datastructures.FloatArray;
  28 import mpi.fruitfly.math.datastructures.FloatArray2D;
  29 import mpi.fruitfly.math.datastructures.FloatArray3D;
  30 import mpi.fruitfly.math.datastructures.FloatArray4D;
  31
  32
  33 public class ImageArrayConverter
  34 {
  35     public static boolean CUTOFF_VALUES = true;
  36     public static boolean NORM_VALUES = false;
  37
  38     public static ImagePlus FloatArrayToImagePlus(FloatArray2D image, String name, float min, float max)
  39     {
  40         ImagePlus imp = IJ.createImage(name,"32-Bit Black", image.width, image.height, 1);
  41         FloatProcessor ip = (FloatProcessor)imp.getProcessor();
  42         FloatArrayToFloatProcessor(ip, image);
  43
  44         if (min == max)
  45             ip.resetMinAndMax();
  46         else
  47             ip.setMinAndMax(min, max);
  48
  49         imp.updateAndDraw();
  50
  51         return imp;
  52     }
  53
  54     public static ImagePlus FloatArrayToStack(FloatArray3D image, String name, float min, float max)
  55     {
  56         int width = image.width;
  57         int height = image.height;
  58         int nstacks = image.depth;
  59
  60         ImageStack stack = new ImageStack(width, height);
  61
  62         for (int slice = 0; slice < nstacks; slice++)
  63         {
  64             ImagePlus impResult = IJ.createImage("Result", "32-Bit Black", width, height, 1);
  65             ImageProcessor ipResult = impResult.getProcessor();
  66             float[] sliceImg = new float[width * height];
  67
  68             for (int x = 0; x < width; x++)
  69                 for (int y = 0; y < height; y++)
  70                     sliceImg[y * width + x] = image.get(x,y,slice);
  71
  72             ipResult.setPixels(sliceImg);
  73
  74             if (min == max)
  75                 ipResult.resetMinAndMax();
  76             else
  77                 ipResult.setMinAndMax(min, max);
  78
  79             stack.addSlice("Slice " + slice, ipResult);
  80         }
  81
  82          return new ImagePlus(name, stack);
  83     }
  84
  85     public static ImagePlus DoubleArrayToStack(double[] image, int width, int height, int nstacks, String name, float min, float max)
  86     {
  87         ImageStack stack = new ImageStack(width, height);
  88
  89         for (int slice = 0; slice < nstacks; slice++)
  90         {
  91             ImagePlus impResult = IJ.createImage("Result", "32-Bit Black", width, height, 1);
  92             ImageProcessor ipResult = impResult.getProcessor();
  93             float[] sliceImg = new float[width * height];
  94
  95             for (int x = 0; x < width; x++)
  96                 for (int y = 0; y < height; y++)
  97                     sliceImg[y * width + x] = (float)image[x + width * (y + slice * height)];
  98
  99             ipResult.setPixels(sliceImg);
 100
 101             if (min == max)
 102                 ipResult.resetMinAndMax();
 103             else
 104                 ipResult.setMinAndMax(min, max);
 105
 106             stack.addSlice("Slice " + slice, ipResult);
 107         }
 108
 109          return new ImagePlus(name, stack);
 110     }
 111
 112     public static FloatArray3D StackToFloatArrayZeroPadding(ImageStack stack, int wZP, int hZP, int dZP)
 113     {
 114         Object[] imageStack = stack.getImageArray();
 115
 116         int width = stack.getWidth();
 117         int height = stack.getHeight();
 118         int nstacks = stack.getSize();
 119
 120         int offsetX = (wZP - width)/2;
 121         int offsetY = (hZP - height)/2;
 122         int offsetZ = (dZP - nstacks)/2;
 123
 124         if (imageStack == null || imageStack.length == 0)
 125         {
 126             System.out.println("Image Stack is empty.");
 127             return null;
 128         }
 129
 130         if (imageStack[0] instanceof int[])
 131         {
 132             System.out.println("RGB images supported at the moment.");
 133             return null;
 134         }
 135
 136
 137         //float[][][] pixels = new float[wZP][hZP][dZP];
 138         FloatArray3D pixels = new FloatArray3D(wZP,hZP,dZP);
 139
 140         int count, pos;
 141         int stepY = pixels.getPos(0,1,0) - width;
 142
 143         if (imageStack[0] instanceof byte[])
 144         {
 145             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 146             {
 147                 byte[] pixelTmp = (byte[]) imageStack[countSlice];
 148                 count = 0;
 149                 pos = pixels.getPos(offsetX, offsetY, offsetZ + countSlice);
 150
 151                 for (int y = 0; y < height; y++)
 152                 {
 153                     for (int x = 0; x < width; x++)
 154                     {
 155                         //pixels.data[pixels.getPos(x + offsetX, y + offsetY, countSlice + offsetZ)] = (float) (pixelTmp[count++] & 0xff);
 156                         pixels.data[pos++] = (float) (pixelTmp[count++] & 0xff);
 157                     }
 158                     pos += stepY;
 159                 }
 160             }
 161         }
 162         else if (imageStack[0] instanceof short[])
 163             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 164             {
 165                 short[] pixelTmp = (short[])imageStack[countSlice];
 166                 count = 0;
 167                 pos = pixels.getPos(offsetX, offsetY, offsetZ + countSlice);
 168
 169                 for (int y = 0; y < height; y++)
 170                 {
 171                     for (int x = 0; x < width; x++)
 172                     {
 173                         //pixels.data[pixels.getPos(x + offsetX, y + offsetY, countSlice + offsetZ)] = (float) (pixelTmp[count++] & 0xffff);
 174                         pixels.data[pos++] =  (float) (pixelTmp[count++] & 0xffff);
 175                     }
 176                     pos += stepY;
 177                 }
 178             }
 179         else // instance of float[]
 180             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 181             {
 182                 float[] pixelTmp = (float[])imageStack[countSlice];
 183                 count = 0;
 184                 pos = pixels.getPos(offsetX, offsetY, offsetZ + countSlice);
 185
 186                 for (int y = 0; y < height; y++)
 187                 {
 188                     for (int x = 0; x < width; x++)
 189                     {
 190                         //pixels.data[pixels.getPos(x + offsetX, y + offsetY, countSlice + offsetZ)] = pixelTmp[count++];
 191                         pixels.data[pos++] = pixelTmp[count++];
 192                     }
 193                     pos += stepY;
 194                 }
 195             }
 196
 197         return pixels;
 198     }
 199
 200     public static FloatArray4D StackToFloatArrayComplexZeroPadding(ImageStack stack, int wZP, int hZP, int dZP)
 201     {
 202         Object[] imageStack = stack.getImageArray();
 203
 204         int width = stack.getWidth();
 205         int height = stack.getHeight();
 206         int nstacks = stack.getSize();
 207
 208         int offsetX = (wZP - width)/2;
 209         int offsetY = (hZP - height)/2;
 210         int offsetZ = (dZP - nstacks)/2;
 211
 212         if (imageStack == null || imageStack.length == 0)
 213         {
 214             System.out.println("Image Stack is empty.");
 215             return null;
 216         }
 217
 218         if (imageStack[0] instanceof int[])
 219         {
 220             System.out.println("RGB images supported at the moment.");
 221             return null;
 222         }
 223
 224
 225         //float[][][] pixels = new float[wZP][hZP][dZP];
 226         FloatArray4D pixels = new FloatArray4D(wZP,hZP,dZP,2);
 227
 228         int count, pos;
 229         int stepY = pixels.getPos(0,1,0,0) - width;
 230
 231
 232         if (imageStack[0] instanceof byte[])
 233             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 234             {
 235                 byte[] pixelTmp = (byte[])imageStack[countSlice];
 236                 count = 0;
 237                 pos = pixels.getPos(offsetX, offsetY, offsetZ + countSlice,0);
 238
 239                 for (int y = 0; y < height; y++)
 240                 {
 241                     for (int x = 0; x < width; x++)
 242                     {
 243                         //pixels.data[pixels.getPos(x + offsetX, y + offsetY, countSlice + offsetZ, 0)] = (float) (pixelTmp[count++] & 0xff);
 244                         pixels.data[pos++] = (float) (pixelTmp[count++] & 0xff);
 245                     }
 246                     pos += stepY;
 247                 }
 248             }
 249         else if (imageStack[0] instanceof short[])
 250             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 251             {
 252                 short[] pixelTmp = (short[])imageStack[countSlice];
 253                 count = 0;
 254                 pos = pixels.getPos(offsetX, offsetY, offsetZ + countSlice,0);
 255
 256                 for (int y = 0; y < height; y++)
 257                 {
 258                     for (int x = 0; x < width; x++)
 259                     {
 260                         //pixels.data[pixels.getPos(x + offsetX, y + offsetY, countSlice + offsetZ, 0)] = (float) (pixelTmp[count++] & 0xffff);
 261                         pixels.data[pos++] = (float) (pixelTmp[count++] & 0xffff);
 262                     }
 263                     pos += stepY;
 264                 }
 265             }
 266         else // instance of float[]
 267             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 268             {
 269                 float[] pixelTmp = (float[])imageStack[countSlice];
 270                 count = 0;
 271                 pos = pixels.getPos(offsetX, offsetY, offsetZ + countSlice,0);
 272
 273                 for (int y = 0; y < height; y++)
 274                 {
 275                     for (int x = 0; x < width; x++)
 276                     {
 277                         //pixels.data[pixels.getPos(x + offsetX, y + offsetY, countSlice + offsetZ, 0)] = pixelTmp[count++];
 278                         pixels.data[pos++] = pixelTmp[count++];
 279                     }
 280                     pos += stepY;
 281                 }
 282             }
 283
 284         return pixels;
 285     }
 286
 287     public static double[] StackToDoubleArrayZeroPadding(ImageStack stack, int wZP, int hZP, int dZP)
 288     {
 289         Object[] imageStack = stack.getImageArray();
 290
 291         int width = stack.getWidth();
 292         int height = stack.getHeight();
 293         int nstacks = stack.getSize();
 294
 295         int offsetX = (wZP - width)/2;
 296         int offsetY = (hZP - height)/2;
 297         int offsetZ = (dZP - nstacks)/2;
 298
 299         if (imageStack == null || imageStack.length == 0)
 300         {
 301             System.out.println("Image Stack is empty.");
 302             return null;
 303         }
 304
 305         if (imageStack[0] instanceof int[])
 306         {
 307             System.out.println("RGB images supported at the moment.");
 308             return null;
 309         }
 310
 311
 312         double[] pixels = new double[wZP * hZP * dZP];
 313         int count;
 314
 315         if (imageStack[0] instanceof byte[])
 316             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 317             {
 318                 byte[] pixelTmp = (byte[])imageStack[countSlice];
 319                 count = 0;
 320
 321                 for (int y = 0; y < height; y++)
 322                     for (int x = 0; x < width; x++)
 323                         pixels[(x+offsetX) + width * ((y+offsetY) + (countSlice+offsetZ) * height)] = (pixelTmp[count++] & 0xff);
 324             }
 325         else if (imageStack[0] instanceof short[])
 326             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 327             {
 328                 short[] pixelTmp = (short[])imageStack[countSlice];
 329                 count = 0;
 330
 331                 for (int y = 0; y < height; y++)
 332                     for (int x = 0; x < width; x++)
 333                         pixels[(x+offsetX) + width * ((y+offsetY) + (countSlice+offsetZ) * height)] = (pixelTmp[count++] & 0xffff);
 334             }
 335         else // instance of float[]
 336             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 337             {
 338                 float[] pixelTmp = (float[])imageStack[countSlice];
 339                 count = 0;
 340
 341                 for (int y = 0; y < height; y++)
 342                     for (int x = 0; x < width; x++)
 343                         pixels[(x+offsetX) + wZP * ((y+offsetY) + (countSlice+offsetZ) * hZP)] = pixelTmp[count++];
 344             }
 345
 346         return pixels;
 347     }
 348
 349     //id + nd * (id-1 + nd-1 * (... + n2 * i1))
 350     public static double[] StackToDoubleArray1D(ImageStack stack)
 351     {
 352         Object[] imageStack = stack.getImageArray();
 353         int width = stack.getWidth();
 354         int height = stack.getHeight();
 355         int nstacks = stack.getSize();
 356
 357         if (imageStack == null || imageStack.length == 0)
 358         {
 359             System.out.println("Image Stack is empty.");
 360             return null;
 361         }
 362
 363         if (imageStack[0] instanceof int[])
 364         {
 365             System.out.println("RGB images supported at the moment.");
 366             return null;
 367         }
 368
 369         double[] pixels = new double[width * height * nstacks];
 370         int count;
 371
 372
 373         if (imageStack[0] instanceof byte[])
 374             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 375             {
 376                 byte[] pixelTmp = (byte[])imageStack[countSlice];
 377                 count = 0;
 378
 379                 for (int y = 0; y < height; y++)
 380                     for (int x = 0; x < width; x++)
 381                         pixels[x + width * (y + countSlice * height)] = (pixelTmp[count++] & 0xff);
 382             }
 383         else if (imageStack[0] instanceof short[])
 384             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 385             {
 386                 short[] pixelTmp = (short[])imageStack[countSlice];
 387                 count = 0;
 388
 389                 for (int y = 0; y < height; y++)
 390                     for (int x = 0; x < width; x++)
 391                         pixels[x + width * (y + countSlice * height)] = (float)(pixelTmp[count++] & 0xffff);
 392             }
 393         else // instance of float[]
 394             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 395             {
 396                 float[] pixelTmp = (float[])imageStack[countSlice];
 397                 count = 0;
 398
 399                 for (int y = 0; y < height; y++)
 400                     for (int x = 0; x < width; x++)
 401                         pixels[x + width * (y + countSlice * height)] = pixelTmp[count++];
 402             }
 403
 404
 405         return pixels;
 406     }
 407
 408     public static FloatArray3D StackToFloatArray(ImageStack stack)
 409     {
 410         Object[] imageStack = stack.getImageArray();
 411         int width = stack.getWidth();
 412         int height = stack.getHeight();
 413         int nstacks = stack.getSize();
 414
 415         if (imageStack == null || imageStack.length == 0)
 416         {
 417             System.out.println("Image Stack is empty.");
 418             return null;
 419         }
 420
 421         if (imageStack[0] instanceof int[])
 422         {
 423             System.out.println("RGB images supported at the moment.");
 424             return null;
 425         }
 426
 427         FloatArray3D pixels = new FloatArray3D(width, height, nstacks);
 428         //float[][][] pixels = new float[width][height][nstacks];
 429         int count;
 430
 431
 432         if (imageStack[0] instanceof byte[])
 433             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 434             {
 435                 byte[] pixelTmp = (byte[])imageStack[countSlice];
 436                 count = 0;
 437
 438                 for (int y = 0; y < height; y++)
 439                     for (int x = 0; x < width; x++)
 440                         pixels.data[pixels.getPos(x,y,countSlice)] = (float)(pixelTmp[count++] & 0xff);
 441             }
 442         else if (imageStack[0] instanceof short[])
 443             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 444             {
 445                 short[] pixelTmp = (short[])imageStack[countSlice];
 446                 count = 0;
 447
 448                 for (int y = 0; y < height; y++)
 449                     for (int x = 0; x < width; x++)
 450                         pixels.data[pixels.getPos(x,y,countSlice)] = (float)(pixelTmp[count++] & 0xffff);
 451             }
 452         else // instance of float[]
 453             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 454             {
 455                 float[] pixelTmp = (float[])imageStack[countSlice];
 456                 count = 0;
 457
 458                 for (int y = 0; y < height; y++)
 459                     for (int x = 0; x < width; x++)
 460                         pixels.data[pixels.getPos(x,y,countSlice)] = pixelTmp[count++];
 461             }
 462
 463
 464         return pixels;
 465     }
 466
 467     public static float[][][] StackToFloatArrayDeprecated(ImageStack stack)
 468     {
 469         Object[] imageStack = stack.getImageArray();
 470         int width = stack.getWidth();
 471         int height = stack.getHeight();
 472         int nstacks = stack.getSize();
 473
 474         if (imageStack == null || imageStack.length == 0)
 475         {
 476             System.out.println("Image Stack is empty.");
 477             return null;
 478         }
 479
 480         if (imageStack[0] instanceof int[])
 481         {
 482             System.out.println("RGB images supported at the moment.");
 483             return null;
 484         }
 485
 486         float[][][] pixels = new float[width][height][nstacks];
 487         int count;
 488
 489
 490         if (imageStack[0] instanceof byte[])
 491             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 492             {
 493                 byte[] pixelTmp = (byte[])imageStack[countSlice];
 494                 count = 0;
 495
 496                 for (int y = 0; y < height; y++)
 497                     for (int x = 0; x < width; x++)
 498                         pixels[x][y][countSlice] = (float)(pixelTmp[count++] & 0xff);
 499             }
 500         else if (imageStack[0] instanceof short[])
 501             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 502             {
 503                 short[] pixelTmp = (short[])imageStack[countSlice];
 504                 count = 0;
 505
 506                 for (int y = 0; y < height; y++)
 507                     for (int x = 0; x < width; x++)
 508                         pixels[x][y][countSlice] = (float)(pixelTmp[count++] & 0xffff);
 509             }
 510         else // instance of float[]
 511             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 512             {
 513                 float[] pixelTmp = (float[])imageStack[countSlice];
 514                 count = 0;
 515
 516                 for (int y = 0; y < height; y++)
 517                     for (int x = 0; x < width; x++)
 518                         pixels[x][y][countSlice] = pixelTmp[count++];
 519             }
 520
 521
 522         return pixels;
 523     }
 524
 525     public static FloatArray4D StackToFloatArrayComplex(ImageStack stack)
 526     {
 527         Object[] imageStack = stack.getImageArray();
 528         int width = stack.getWidth();
 529         int height = stack.getHeight();
 530         int nstacks = stack.getSize();
 531
 532         if (imageStack == null || imageStack.length == 0)
 533         {
 534             System.out.println("Image Stack is empty.");
 535             return null;
 536         }
 537
 538         if (imageStack[0] instanceof int[])
 539         {
 540             System.out.println("RGB images supported at the moment.");
 541             return null;
 542         }
 543
 544         FloatArray4D pixels = new FloatArray4D(width, height, nstacks, 2);
 545         //float[][][] pixels = new float[width][height][nstacks];
 546         int count;
 547
 548
 549         if (imageStack[0] instanceof byte[])
 550             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 551             {
 552                 byte[] pixelTmp = (byte[])imageStack[countSlice];
 553                 count = 0;
 554
 555                 for (int y = 0; y < height; y++)
 556                     for (int x = 0; x < width; x++)
 557                         pixels.data[pixels.getPos(x,y,countSlice,0)] = (float)(pixelTmp[count++] & 0xff);
 558             }
 559         else if (imageStack[0] instanceof short[])
 560             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 561             {
 562                 short[] pixelTmp = (short[])imageStack[countSlice];
 563                 count = 0;
 564
 565                 for (int y = 0; y < height; y++)
 566                     for (int x = 0; x < width; x++)
 567                         pixels.data[pixels.getPos(x,y,countSlice,0)] = (float)(pixelTmp[count++] & 0xffff);
 568             }
 569         else // instance of float[]
 570             for (int countSlice = 0; countSlice < nstacks; countSlice++)
 571             {
 572                 float[] pixelTmp = (float[])imageStack[countSlice];
 573                 count = 0;
 574
 575                 for (int y = 0; y < height; y++)
 576                     for (int x = 0; x < width; x++)
 577                         pixels.data[pixels.getPos(x,y,countSlice,0)] = pixelTmp[count++];
 578             }
 579
 580
 581         return pixels;
 582     }
 583
 584     public static int[][] ImageToIntArray(ImageProcessor ip)
 585     {
 586         int[][] image;
 587         Object pixelArray = ip.getPixels();
 588         int count = 0;
 589
 590         if (ip instanceof ByteProcessor)
 591         {
 592             image = new int[ip.getWidth()][ip.getHeight()];
 593             byte[] pixels = (byte[])pixelArray;
 594
 595             for (int y = 0; y < ip.getHeight(); y++)
 596                 for (int x = 0; x < ip.getWidth(); x++)
 597                     image[x][y] = pixels[count++] & 0xff;
 598         }
 599         else if (ip instanceof ShortProcessor)
 600         {
 601             image = new int[ip.getWidth()][ip.getHeight()];
 602             short[] pixels = (short[])pixelArray;
 603
 604             for (int y = 0; y < ip.getHeight(); y++)
 605                 for (int x = 0; x < ip.getWidth(); x++)
 606                     image[x][y] = pixels[count++] & 0xffff;
 607         }
 608         else if (ip instanceof FloatProcessor)
 609         {
 610             image = new int[ip.getWidth()][ip.getHeight()];
 611             float[] pixels = (float[])pixelArray;
 612
 613             for (int y = 0; y < ip.getHeight(); y++)
 614                 for (int x = 0; x < ip.getWidth(); x++)
 615                     image[x][y] = (int)pixels[count++];
 616         }
 617         else //RGB
 618         {
 619             image = new int[ip.getWidth()][ip.getHeight()];
 620             int[] pixels = (int[])pixelArray;
 621
 622             // still unknown how to do...
 623
 624             /*
 625             for (int y = 0; y < ip.getHeight(); y++)
 626                 for (int x = 0; x < ip.getWidth(); x++)
 627                         image[x][y] = pixels[count++];// & 0xffffff;
 628             */
 629         }
 630
 631         return image;
 632     }
 633
 634     public static float[][] ImageToFloatArray2DDeprecated(ImageProcessor ip)
 635     {
 636         float[][] image;
 637         Object pixelArray = ip.getPixels();
 638         int count = 0;
 639
 640         if (ip instanceof ByteProcessor)
 641         {
 642             image = new float[ip.getWidth()][ip.getHeight()];
 643             byte[] pixels = (byte[])pixelArray;
 644
 645             for (int y = 0; y < ip.getHeight(); y++)
 646                 for (int x = 0; x < ip.getWidth(); x++)
 647                     image[x][y] = pixels[count++] & 0xff;
 648         }
 649         else if (ip instanceof ShortProcessor)
 650         {
 651             image = new float[ip.getWidth()][ip.getHeight()];
 652             short[] pixels = (short[])pixelArray;
 653
 654             for (int y = 0; y < ip.getHeight(); y++)
 655                 for (int x = 0; x < ip.getWidth(); x++)
 656                     image[x][y] = pixels[count++] & 0xffff;
 657         }
 658         else if (ip instanceof FloatProcessor)
 659         {
 660             image = new float[ip.getWidth()][ip.getHeight()];
 661             float[] pixels = (float[])pixelArray;
 662
 663             for (int y = 0; y < ip.getHeight(); y++)
 664                 for (int x = 0; x < ip.getWidth(); x++)
 665                     image[x][y] = pixels[count++];
 666         }
 667         else //RGB
 668         {
 669             image = new float[ip.getWidth()][ip.getHeight()];
 670             int[] pixels = (int[])pixelArray;
 671
 672             // still unknown how to do...
 673
 674             /*
 675             for (int y = 0; y < ip.getHeight(); y++)
 676                 for (int x = 0; x < ip.getWidth(); x++)
 677                         image[x][y] = pixels[count++];// & 0xffffff;
 678             */
 679         }
 680
 681         return image;
 682     }
 683
 684     public static double[] ImageToDoubleArray1D(ImageProcessor ip)
 685     {
 686         double[] image;
 687         Object pixelArray = ip.getPixels();
 688         int count = 0;
 689
 690         if (ip instanceof ByteProcessor)
 691         {
 692             image = new double[ip.getWidth() * ip.getHeight()];
 693             byte[] pixels = (byte[])pixelArray;
 694
 695             for (int y = 0; y < ip.getHeight(); y++)
 696                 for (int x = 0; x < ip.getWidth(); x++)
 697                     image[count] = pixels[count++] & 0xff;
 698         }
 699         else if (ip instanceof ShortProcessor)
 700         {
 701             image = new double[ip.getWidth() * ip.getHeight()];
 702             short[] pixels = (short[])pixelArray;
 703
 704             for (int y = 0; y < ip.getHeight(); y++)
 705                 for (int x = 0; x < ip.getWidth(); x++)
 706                     image[count] = pixels[count++] & 0xffff;
 707         }
 708         else if (ip instanceof FloatProcessor)
 709         {
 710             image = new double[ip.getWidth() * ip.getHeight()];
 711             float[] pixels = (float[])pixelArray;
 712
 713             for (int y = 0; y < ip.getHeight(); y++)
 714                 for (int x = 0; x < ip.getWidth(); x++)
 715                     image[count] = pixels[count++];
 716         }
 717         else //RGB
 718         {
 719             image = new double[ip.getWidth() * ip.getHeight()];
 720             int[] pixels = (int[])pixelArray;
 721
 722             // still unknown how to do...
 723
 724             /*
 725             for (int y = 0; y < ip.getHeight(); y++)
 726                 for (int x = 0; x < ip.getWidth(); x++)
 727                         image[x][y] = pixels[count++];// & 0xffffff;
 728             */
 729         }
 730
 731         return image;
 732     }
 733
 734     public static FloatArray2D ImageToFloatArray2D(ImageProcessor ip)
 735     {
 736         FloatArray2D image;
 737         Object pixelArray = ip.getPixels();
 738         int count = 0;
 739
 740         if (ip instanceof ByteProcessor)
 741         {
 742             image = new FloatArray2D(ip.getWidth(),  ip.getHeight());
 743             byte[] pixels = (byte[])pixelArray;
 744
 745             for (int y = 0; y < ip.getHeight(); y++)
 746                 for (int x = 0; x < ip.getWidth(); x++)
 747                     image.data[count] = pixels[count++] & 0xff;
 748         }
 749         else if (ip instanceof ShortProcessor)
 750         {
 751             image = new FloatArray2D(ip.getWidth(),  ip.getHeight());
 752             short[] pixels = (short[])pixelArray;
 753
 754             for (int y = 0; y < ip.getHeight(); y++)
 755                 for (int x = 0; x < ip.getWidth(); x++)
 756                     image.data[count] = pixels[count++] & 0xffff;
 757         }
 758         else if (ip instanceof FloatProcessor)
 759         {
 760             image = new FloatArray2D(ip.getWidth(),  ip.getHeight());
 761             float[] pixels = (float[])pixelArray;
 762
 763             for (int y = 0; y < ip.getHeight(); y++)
 764                 for (int x = 0; x < ip.getWidth(); x++)
 765                     image.data[count] = pixels[count++];
 766         }
 767         else //RGB
 768         {
 769             image = new FloatArray2D(ip.getWidth(),  ip.getHeight());
 770             int[] pixels = (int[])pixelArray;
 771
 772             // still unknown how to do...
 773
 774             /*
 775             for (int y = 0; y < ip.getHeight(); y++)
 776                 for (int x = 0; x < ip.getWidth(); x++)
 777                         image[x][y] = pixels[count++];// & 0xffffff;
 778             */
 779         }
 780
 781         return image;
 782     }
 783
 784     public static void normFloatArray(FloatArray img)
 785     {
 786         float min = img.data[0];
 787         float max = img.data[0];
 788
 789         for (float f : img.data)
 790         {
 791             if (f > max)
 792                 max = f;
 793
 794             if (f < min)
 795                 min = f;
 796         }
 797
 798         for (int i = 0; i < img.data.length; i++)
 799             img.data[i] = (img.data[i] - min)/(max-min);
 800     }
 801
 802     public static int DRAWTYPE_OVERLAP = 0;
 803     public static int DRAWTYPE_ERRORMAP = 1;
 804
 805     public static FloatArray2D drawTranslatedImages(FloatArray2D img1, FloatArray2D img2, Point shift, int drawType)
 806     {
 807         int w1 = img1.width;
 808         int h1 = img1.height;
 809
 810         int w2 = img2.width;
 811         int h2 = img2.height;
 812
 813         boolean createOverlappingImages = (drawType == DRAWTYPE_OVERLAP);
 814         boolean createErrorMap = (drawType == DRAWTYPE_ERRORMAP);
 815
 816         int sx = shift.x;
 817         int sy = shift.y;
 818
 819         int imgW = max(w1, w2) + max(0, Math.abs(sx) - Math.abs((w1 - w2)));
 820         int imgH = max(h1, h2) + max(0, Math.abs(sy) - Math.abs((h1 - h2)));
 821
 822         FloatArray2D outputImg = new FloatArray2D(imgW, imgH);
 823
 824         int offsetImg1X = max(0, -sx); // + max(0, max(0, -sx) - max(0, (w1 - w2)/2));
 825         int offsetImg1Y = max(0, -sy); // + max(0, max(0, -sy) - max(0, (h1 - h2)/2));
 826         int offsetImg2X = max(0, sx); // + max(0, max(0, sx) - max(0, (w2 - w1)/2));
 827         int offsetImg2Y = max(0, sy); // + max(0, max(0, sy) - max(0, (h2 - h1)/2));
 828
 829         float pixel1, pixel2;
 830
 831         // iterate over whole image
 832         for (int y = 0; y < imgH; y++)
 833             for (int x = 0; x < imgW; x++)
 834             {
 835                 pixel1 = img1.getZero(x - offsetImg1X, y - offsetImg1Y);
 836                 pixel2 = img2.getZero(x - offsetImg2X, y - offsetImg2Y);
 837
 838                 if (createOverlappingImages)
 839                     outputImg.set( (pixel1 + pixel2) / 2f, x, y);
 840
 841                 // compute errors only if the images overlap
 842                 if (x >= offsetImg1X && x >= offsetImg2X &&
 843                     x < offsetImg1X + w1 && x < offsetImg2X + w2 &&
 844                     y >= offsetImg1Y && y >= offsetImg2Y &&
 845                     y < offsetImg1Y + h1 && y < offsetImg2Y + h2)
 846                 {
 847                     if (createErrorMap)
 848                         outputImg.set( (pixel1 + pixel2) / 2f, x, y);
 849                 }
 850             }
 851
 852         return outputImg;
 853     }
 854
 855     public static FloatArray2D zeroPad(FloatArray2D ip, int width, int height)
 856     {
 857         FloatArray2D image = new FloatArray2D(width,  height);
 858
 859         int offsetX = (width - ip.width)/2;
 860         int offsetY = (height - ip.height)/2;
 861
 862         if (offsetX < 0)
 863         {
 864             System.err.println("mpi.fruitfly.general.ImageArrayConverter.ZeroPad(): Zero-Padding size in X smaller than image! " + width + " < " + ip.width);
 865             return null;
 866         }
 867
 868         if (offsetY < 0)
 869         {
 870             System.err.println("mpi.fruitfly.general.ImageArrayConverter.ZeroPad(): Zero-Padding size in Y smaller than image! " + height + " < " + ip.height);
 871             return null;
 872         }
 873
 874         int count = 0;
 875
 876         for (int y = 0; y < ip.height; y++)
 877             for (int x = 0; x < ip.width; x++)
 878                 image.set(ip.data[count++], x+offsetX, y+offsetY);
 879
 880         return image;
 881     }
 882
 883
 884     public static FloatArray2D ImageToFloatArray2DZeroPadding(ImageProcessor ip, int width, int height)
 885     {
 886         FloatArray2D image = new FloatArray2D(width,  height);
 887         Object pixelArray = ip.getPixels();
 888         int count = 0;
 889
 890         int offsetX = (width - ip.getWidth())/2;
 891         int offsetY = (height - ip.getHeight())/2;
 892
 893         if (offsetX < 0)
 894         {
 895             System.err.println("mpi.fruitfly.general.ImageArrayConverter.ImageToFloatArray2DZeroPadding(): Zero-Padding size in X smaller than image! " + width + " < " + ip.getWidth());
 896             return null;
 897         }
 898
 899         if (offsetY < 0)
 900         {
 901             System.err.println("mpi.fruitfly.general.ImageArrayConverter.ImageToFloatArray2DZeroPadding(): Zero-Padding size in Y smaller than image! " + height + " < " + ip.getHeight());
 902             return null;
 903         }
 904
 905         if (ip instanceof ByteProcessor)
 906         {
 907             byte[] pixels = (byte[])pixelArray;
 908
 909             for (int y = 0; y < ip.getHeight(); y++)
 910                 for (int x = 0; x < ip.getWidth(); x++)
 911                     image.set(pixels[count++] & 0xff, x+offsetX, y+offsetY);
 912         }
 913         else if (ip instanceof ShortProcessor)
 914         {
 915             short[] pixels = (short[])pixelArray;
 916
 917             for (int y = 0; y < ip.getHeight(); y++)
 918                 for (int x = 0; x < ip.getWidth(); x++)
 919                     image.set(pixels[count++] & 0xffff, x+offsetX, y+offsetY);
 920         }
 921         else if (ip instanceof FloatProcessor)
 922         {
 923             float[] pixels = (float[])pixelArray;
 924
 925             for (int y = 0; y < ip.getHeight(); y++)
 926                 for (int x = 0; x < ip.getWidth(); x++)
 927                     image.set(pixels[count++], x+offsetX, y+offsetY);
 928         }
 929         else //RGB
 930         {
 931             int[] pixels = (int[])pixelArray;
 932
 933             // still unknown how to do...
 934
 935             /*
 936             for (int y = 0; y < ip.getHeight(); y++)
 937                 for (int x = 0; x < ip.getWidth(); x++)
 938                         image[x][y] = pixels[count++];// & 0xffffff;
 939             */
 940         }
 941
 942         return image;
 943     }
 944
 945
 946     public static double[] ImageToDoubleArray1DZeroPadding(ImageProcessor ip, int width, int height)
 947     {
 948         double[] image;
 949         Object pixelArray = ip.getPixels();
 950         int count = 0;
 951
 952         int offsetX = (width - ip.getWidth())/2;
 953         int offsetY = (height - ip.getHeight())/2;
 954
 955         if (offsetX < 0)
 956         {
 957             System.err.println("mpi.fruitfly.general.ImageArrayConverter.ImageToDoubleArray1DZeroPadding(): Zero-Padding size in X smaller than image! " + width + " < " + ip.getWidth());
 958             return null;
 959         }
 960
 961         if (offsetY < 0)
 962         {
 963             System.err.println("mpi.fruitfly.general.ImageArrayConverter.ImageToDoubleArray1DZeroPadding(): Zero-Padding size in Y smaller than image! " + height + " < " + ip.getHeight());
 964             return null;
 965         }
 966
 967         if (ip instanceof ByteProcessor)
 968         {
 969             image = new double[width * height];
 970             byte[] pixels = (byte[])pixelArray;
 971
 972             for (int y = 0; y < ip.getHeight(); y++)
 973                 for (int x = 0; x < ip.getWidth(); x++)
 974                     image[(y+offsetY)*width + x + offsetX] = pixels[count++] & 0xff;
 975         }
 976         else if (ip instanceof ShortProcessor)
 977         {
 978             image = new double[width * height];
 979             short[] pixels = (short[])pixelArray;
 980
 981             for (int y = 0; y < ip.getHeight(); y++)
 982                 for (int x = 0; x < ip.getWidth(); x++)
 983                     image[(y+offsetY)*width + x + offsetX] = pixels[count++] & 0xffff;
 984         }
 985         else if (ip instanceof FloatProcessor)
 986         {
 987             image = new double[width * height];
 988             float[] pixels = (float[])pixelArray;
 989
 990             for (int y = 0; y < ip.getHeight(); y++)
 991                 for (int x = 0; x < ip.getWidth(); x++)
 992                     image[(y+offsetY)*width + x + offsetX] = pixels[count++];
 993         }
 994         else //RGB
 995         {
 996             image = new double[width * height];
 997             int[] pixels = (int[])pixelArray;
 998
 999             // still unknown how to do...
1000
1001             /*
1002             for (int y = 0; y < ip.getHeight(); y++)
1003                 for (int x = 0; x < ip.getWidth(); x++)
1004                         image[x][y] = pixels[count++];// & 0xffffff;
1005             */
1006         }
1007
1008         return image;
1009     }
1010
1011     public static void ArrayToByteProcessor(ImageProcessor ip, int[][] pixels)
1012     {
1013         byte[] data = new byte[pixels.length * pixels[0].length];
1014
1015         int count = 0;
1016         for (int y = 0; y < pixels[0].length; y++)
1017             for (int x = 0; x < pixels.length; x++)
1018                 data[count++] = (byte)(pixels[x][y] & 0xff);
1019
1020         ip.setPixels(data);
1021     }
1022
1023     public static void ArrayToByteProcessor(ImageProcessor ip, float[][] pixels)
1024     {
1025         byte[] data = new byte[pixels.length * pixels[0].length];
1026
1027         int count = 0;
1028         for (int y = 0; y < pixels[0].length; y++)
1029             for (int x = 0; x < pixels.length; x++)
1030                 data[count++] = (byte)(((int)pixels[x][y]) & 0xff);
1031
1032         ip.setPixels(data);
1033     }
1034
1035     public static void ArrayToFloatProcessor(ImageProcessor ip, double[] pixels, int width, int height)
1036     {
1037         float[] data = new float[width * height];
1038
1039         int count = 0;
1040         for (int y = 0; y < height; y++)
1041             for (int x = 0; x < width; x++)
1042                 data[count] = (float)pixels[count++];
1043
1044         ip.setPixels(data);
1045         ip.resetMinAndMax();
1046     }
1047
1048     public static void ArrayToFloatProcessor(ImageProcessor ip, float[] pixels, int width, int height)
1049     {
1050         float[] data = new float[width * height];
1051
1052         int count = 0;
1053         for (int y = 0; y < height; y++)
1054             for (int x = 0; x < width; x++)
1055                 data[count] = (float)pixels[count++];
1056
1057         ip.setPixels(data);
1058         ip.resetMinAndMax();
1059     }
1060
1061     public static void FloatArrayToFloatProcessor(ImageProcessor ip, FloatArray2D pixels)
1062     {
1063         float[] data = new float[pixels.width * pixels.height];
1064
1065         int count = 0;
1066         for (int y = 0; y < pixels.height; y++)
1067             for (int x = 0; x < pixels.width; x++)
1068                 data[count] = pixels.data[count++];
1069
1070         ip.setPixels(data);
1071         ip.resetMinAndMax();
1072     }
1073
1074     public static void normPixelValuesToByte(int[][] pixels, boolean cutoff)
1075     {
1076         int max = 0, min = 255;
1077
1078         // check minmal and maximal values or cut of values that are higher or lower than 255 resp. 0
1079         for (int y = 0; y < pixels[0].length; y++)
1080             for (int x = 0; x < pixels.length; x++)
1081             {
1082                 if (cutoff)
1083                 {
1084                     if (pixels[x][y] < 0)
1085                         pixels[x][y] = 0;
1086
1087                     if (pixels[x][y] > 255)
1088                         pixels[x][y] = 255;
1089                 }
1090                 else
1091                 {
1092                     if (pixels[x][y] < min)
1093                         min = pixels[x][y];
1094
1095                     if (pixels[x][y] > max)
1096                         max = pixels[x][y];
1097                 }
1098             }
1099
1100         if (cutoff)
1101             return;
1102
1103
1104         // if they do not match bytevalues we have to do something
1105         if (max > 255 || min < 0)
1106         {
1107             double factor;
1108
1109             factor = (max-min) / 255.0;
1110
1111             for (int y = 0; y < pixels[0].length; y++)
1112                 for (int x = 0; x < pixels.length; x++)
1113                     pixels[x][y] = (int)((pixels[x][y] - min) / factor);
1114         }
1115     }
1116
1117     public static void normPixelValuesToByte(float[][] pixels, boolean cutoff)
1118     {
1119         float max = 0, min = 255;
1120
1121         // check minmal and maximal values or cut of values that are higher or lower than 255 resp. 0
1122         for (int y = 0; y < pixels[0].length; y++)
1123             for (int x = 0; x < pixels.length; x++)
1124             {
1125                 if (cutoff)
1126                 {
1127                     if (pixels[x][y] < 0)
1128                         pixels[x][y] = 0;
1129
1130                     if (pixels[x][y] > 255)
1131                         pixels[x][y] = 255;
1132                 }
1133                 else
1134                 {
1135                     if (pixels[x][y] < min)
1136                         min = pixels[x][y];
1137
1138                     if (pixels[x][y] > max)
1139                         max = pixels[x][y];
1140                 }
1141             }
1142
1143         if (cutoff)
1144             return;
1145
1146
1147         // if they do not match bytevalues we have to do something
1148         if (max > 255 || min < 0)
1149         {
1150             double factor;
1151
1152             factor = (max-min) / 255.0;
1153
1154             for (int y = 0; y < pixels[0].length; y++)
1155                 for (int x = 0; x < pixels.length; x++)
1156                     pixels[x][y] = (int)((pixels[x][y] - min) / factor);
1157         }
1158     }
1159
1160     public static void normPixelValuesToByte(float[][][] pixels, boolean cutoff)
1161     {
1162         float max = 0, min = 255;
1163
1164         // check minmal and maximal values or cut of values that are higher or lower than 255 resp. 0
1165         for (int z = 0; z < pixels[0][0].length; z++)
1166             for (int y = 0; y < pixels[0].length; y++)
1167                 for (int x = 0; x < pixels.length; x++)
1168                 {
1169                     if (cutoff)
1170                     {
1171                         if (pixels[x][y][z] < 0)
1172                             pixels[x][y][z] = 0;
1173
1174                         if (pixels[x][y][z] > 255)
1175                             pixels[x][y][z] = 255;
1176                     }
1177                     else
1178                     {
1179                         if (pixels[x][y][z] < min)
1180                             min = pixels[x][y][z];
1181
1182                         if (pixels[x][y][z] > max)
1183                             max = pixels[x][y][z];
1184                     }
1185                 }
1186
1187         if (cutoff)
1188             return;
1189
1190
1191         // if they do not match bytevalues we have to do something
1192         if (max > 255 || min < 0)
1193         {
1194             double factor;
1195
1196             factor = (max-min) / 255.0;
1197
1198             for (int z = 0; z < pixels[0][0].length; z++)
1199                 for (int y = 0; y < pixels[0].length; y++)
1200                     for (int x = 0; x < pixels.length; x++)
1201                         pixels[x][y][z] = (int)((pixels[x][y][z] - min) / factor);
1202         }
1203     }
1204
1205 }