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