Source code

001/*-
002 *******************************************************************************
003 * Copyright (c) 2011, 2016 Diamond Light Source Ltd.
004 * All rights reserved. This program and the accompanying materials
005 * are made available under the terms of the Eclipse Public License v1.0
006 * which accompanies this distribution, and is available at
007 * http://www.eclipse.org/legal/epl-v10.html
008 *
009 * Contributors:
010 *    Peter Chang - initial API and implementation and/or initial documentation
011 *******************************************************************************/
012
013package org.eclipse.january.dataset;
014
015import java.util.Arrays;
016
017/**
018 * Class to hold colour datasets as red, green, blue tuples of short integers
019 */
020public class RGBDataset extends CompoundShortDataset implements Cloneable {
021        // pin UID to base class
022        private static final long serialVersionUID = Dataset.serialVersionUID;
023
024        private static final int ISIZE = 3; // number of elements per item
025
026        @Override
027        public int getDType() {
028                return Dataset.RGB;
029        }
030
031        /**
032         * Create a null dataset
033         */
034        public RGBDataset() {
035                super(ISIZE);
036        }
037
038        public RGBDataset(final int... shape) {
039                super(ISIZE, shape);
040        }
041
042        public RGBDataset(final short[] data, final int... shape) {
043                super(ISIZE, data, shape);
044        }
045
046        /**
047         * Copy a dataset
048         * @param dataset
049         */
050        public RGBDataset(final RGBDataset dataset) {
051                super(dataset);
052        }
053
054        @Override
055        public RGBDataset clone() {
056                return new RGBDataset(this);
057        }
058
059        /**
060         * Create a dataset using given data (red, green and blue parts are given separately)
061         * @param redData
062         * @param greenData
063         * @param blueData
064         * @param shape (can be null to create 1D dataset)
065         */
066        public RGBDataset(final int[] redData, final int[] greenData, final int[] blueData, int... shape) {
067                int dsize = redData.length > greenData.length ? greenData.length : redData.length;
068                dsize = dsize > blueData.length ? blueData.length : dsize;
069                if (shape == null || shape.length == 0) {
070                        shape = new int[] {dsize};
071                }
072                isize = ISIZE;
073                size = ShapeUtils.calcSize(shape);
074                if (size != dsize) {
075                        logger.error("Shape is not compatible with size of data array");
076                        throw new IllegalArgumentException("Shape is not compatible with size of data array");
077                }
078                this.shape = shape.clone();
079
080                try {
081                        odata = data = createArray(size);
082                } catch (Throwable t) {
083                        logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t);
084                        throw new IllegalArgumentException(t);
085                }
086
087                for (int i = 0, n = 0; i < size; i++) {
088                        data[n++] = (short) redData[i];
089                        data[n++] = (short) greenData[i];
090                        data[n++] = (short) blueData[i];
091                }
092        }
093
094        /**
095         * Create a dataset using given data (red, green and blue parts are given separately)
096         * @param redData
097         * @param greenData
098         * @param blueData
099         * @param shape (can be null to create 1D dataset)
100         */
101        public RGBDataset(final short[] redData, final short[] greenData, final short[] blueData, int... shape) {
102                int dsize = redData.length > greenData.length ? greenData.length : redData.length;
103                dsize = dsize > blueData.length ? blueData.length : dsize;
104                if (shape == null || shape.length == 0) {
105                        shape = new int[] {dsize};
106                }
107                isize = ISIZE;
108                size = ShapeUtils.calcSize(shape);
109                if (size != dsize) {
110                        logger.error("Shape is not compatible with size of data array");
111                        throw new IllegalArgumentException("Shape is not compatible with size of data array");
112                }
113                this.shape = shape.clone();
114
115                try {
116                        odata = data = createArray(size);
117                } catch (Throwable t) {
118                        logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t);
119                        throw new IllegalArgumentException(t);
120                }
121
122                for (int i = 0, n = 0; i < size; i++) {
123                        data[n++] = redData[i];
124                        data[n++] = greenData[i];
125                        data[n++] = blueData[i];
126                }
127        }
128
129        /**
130         * Create a dataset using given data (red, green and blue parts are given separately)
131         * @param redData
132         * @param greenData
133         * @param blueData
134         * @param shape (can be null to create 1D dataset)
135         */
136        public RGBDataset(final byte[] redData, final byte[] greenData, final byte[] blueData, int... shape) {
137                int dsize = redData.length > greenData.length ? greenData.length : redData.length;
138                dsize = dsize > blueData.length ? blueData.length : dsize;
139                if (shape == null || shape.length == 0) {
140                        shape = new int[] {dsize};
141                }
142                isize = ISIZE;
143                size = ShapeUtils.calcSize(shape);
144                if (size != dsize) {
145                        logger.error("Shape is not compatible with size of data array");
146                        throw new IllegalArgumentException("Shape is not compatible with size of data array");
147                }
148                this.shape = shape.clone();
149
150                try {
151                        odata = data = createArray(size);
152                } catch (Throwable t) {
153                        logger.error("Could not create a dataset of shape {}", Arrays.toString(shape), t);
154                        throw new IllegalArgumentException(t);
155                }
156
157                for (int i = 0, n = 0; i < size; i++) {
158                        data[n++] = (short) (0xff & redData[i]);
159                        data[n++] = (short) (0xff & greenData[i]);
160                        data[n++] = (short) (0xff & blueData[i]);
161                }
162        }
163
164        /**
165         * Create a dataset using given colour data (colour components are given separately)
166         * @param red
167         * @param green
168         * @param blue
169         */
170        public RGBDataset(final Dataset red, final Dataset green, final Dataset blue) {
171                super(ISIZE, red.getShapeRef());
172                red.checkCompatibility(green);
173                red.checkCompatibility(blue);
174
175                if (red.max().doubleValue() > Short.MAX_VALUE || red.min().doubleValue() < Short.MIN_VALUE ||
176                                green.max().doubleValue() > Short.MAX_VALUE || green.min().doubleValue() < Short.MIN_VALUE || 
177                                blue.max().doubleValue() > Short.MAX_VALUE || blue.min().doubleValue() < Short.MIN_VALUE) {
178                        logger.warn("Some values are out of range and will be ");
179                }
180
181                IndexIterator riter = red.getIterator();
182                IndexIterator giter = green.getIterator();
183                IndexIterator biter = blue.getIterator();
184
185                for (int i = 0; riter.hasNext() && giter.hasNext() && biter.hasNext();) {
186                        data[i++] = (short) red.getElementLongAbs(riter.index);
187                        data[i++] = (short) green.getElementLongAbs(riter.index);
188                        data[i++] = (short) blue.getElementLongAbs(riter.index);
189                }
190        }
191
192        /**
193         * Create a dataset using given grey data
194         * @param grey
195         */
196        public RGBDataset(final Dataset grey) {
197                super(ISIZE, grey.getShapeRef());
198
199                IndexIterator giter = grey.getIterator();
200
201                for (int i = 0; giter.hasNext();) {
202                        final short g = (short) grey.getElementLongAbs(giter.index); 
203                        data[i++] = g;
204                        data[i++] = g;
205                        data[i++] = g;
206                }
207        }
208
209        /**
210         * Create a RGB dataset from an object which could be a Java list, array (of arrays...) or Number. Ragged
211         * sequences or arrays are padded with zeros. The item size is the last dimension of the corresponding
212         * elemental dataset
213         *
214         * @param obj
215         * @return dataset with contents given by input
216         */
217        public static RGBDataset createFromObject(final Object obj) {
218                CompoundShortDataset result = (CompoundShortDataset) DatasetUtils.createCompoundDataset(ShortDataset.createFromObject(obj), ISIZE);
219                return new RGBDataset(result.data, result.shape);
220        }
221
222        /**
223         * Create a RGB dataset from a compound dataset (no normalisation performed)
224         * @param a
225         * @return RGB dataset (grey if input dataset has less than 3 elements per item)
226         */
227        public static RGBDataset createFromCompoundDataset(final CompoundDataset a) {
228                if (a instanceof RGBDataset)
229                        return (RGBDataset) a;
230                final int is = a.getElementsPerItem();
231                if (is < 3) {
232                        return new RGBDataset(a);
233                }
234
235                if (a instanceof CompoundShortDataset && is == 3) {
236                        return new RGBDataset((short[]) a.getBuffer(), a.getShapeRef());
237                }
238
239                final RGBDataset rgb = new RGBDataset(a.getShapeRef());
240                final IndexIterator it = a.getIterator();
241
242                int n = 0;
243                while (it.hasNext()) {
244                        rgb.data[n++] = (short) a.getElementLongAbs(it.index);
245                        rgb.data[n++] = (short) a.getElementLongAbs(it.index + 1);
246                        rgb.data[n++] = (short) a.getElementLongAbs(it.index + 2);
247                }
248
249                return rgb;
250        }
251
252        /**
253         * Create a RGB dataset from hue, saturation and value dataset
254         * @param hue (in degrees from -360 to 360)
255         * @param saturation (from 0 to 1), can be null to denote 1
256         * @param value (from 0 to 1)
257         * @return RGB dataset
258         */
259        public static RGBDataset createFromHSV(final Dataset hue, final Dataset saturation, final Dataset value) {
260                if ((saturation != null && !hue.isCompatibleWith(saturation)) || !hue.isCompatibleWith(value)) {
261                        throw new IllegalArgumentException("Hue, saturation and value datasets must have the same shape");
262                }
263
264                RGBDataset result = new RGBDataset(hue.getShapeRef());
265                IndexIterator it = result.getIterator(true);
266                int[] pos = it.getPos();
267                short[] rgb = new short[3];
268
269                if (saturation == null) {
270                        while (it.hasNext()) {
271                                convertHSVToRGB(hue.getDouble(pos), 1, value.getDouble(pos), rgb);
272                                result.setAbs(it.index, rgb);
273                        }
274                } else {
275                        while (it.hasNext()) {
276                                convertHSVToRGB(hue.getDouble(pos), saturation.getDouble(pos), value.getDouble(pos), rgb);
277                                result.setAbs(it.index, rgb);
278                        }
279                }
280
281                return result;
282        }
283
284        /**
285         * Create a RGB dataset from hue, saturation and lightness dataset
286         * @param hue (in degrees from -360 to 360)
287         * @param saturation (from 0 to 1), can be null to denote 1
288         * @param lightness (from 0 to 1)
289         * @return RGB dataset
290         */
291        public static RGBDataset createFromHSL(final Dataset hue, final Dataset saturation, final Dataset lightness) {
292                if ((saturation != null && !hue.isCompatibleWith(saturation)) || !hue.isCompatibleWith(lightness)) {
293                        throw new IllegalArgumentException("Hue, saturation and lightness datasets must have the same shape");
294                }
295
296                RGBDataset result = new RGBDataset(hue.getShapeRef());
297                IndexIterator it = result.getIterator(true);
298                int[] pos = it.getPos();
299                short[] rgb = new short[3];
300
301                if (saturation == null) {
302                        while (it.hasNext()) {
303                                convertHSLToRGB(hue.getDouble(pos), 1, lightness.getDouble(pos), rgb);
304                                result.setAbs(it.index, rgb);
305                        }
306                } else {
307                        while (it.hasNext()) {
308                                convertHSLToRGB(hue.getDouble(pos), saturation.getDouble(pos), lightness.getDouble(pos), rgb);
309                                result.setAbs(it.index, rgb);
310                        }
311                }
312
313                return result;
314        }
315
316        private static void convertHSVToRGB(double h, double s, double v, short[] rgb) {
317                double m = 255 * v;
318                double chroma = s * m;
319                m -= chroma;
320                double hprime = h / 60.;
321                if (hprime < 0) {
322                        hprime += 6;
323                }
324                short sx = (short) (chroma * (1 - Math.abs((hprime % 2) - 1)) + m);
325                short sc = (short) (chroma + m);
326                short sm = (short) m;
327                
328                if (hprime < 1) {
329                        rgb[0] = sc;
330                        rgb[1] = sx;
331                        rgb[2] = sm;
332                } else if (hprime < 2) {
333                        rgb[0] = sx;
334                        rgb[1] = sc;
335                        rgb[2] = sm;
336                } else if (hprime < 3) {
337                        rgb[0] = sm;
338                        rgb[1] = sc;
339                        rgb[2] = sx;
340                } else if (hprime < 4) {
341                        rgb[0] = sm;
342                        rgb[1] = sx;
343                        rgb[2] = sc;
344                } else if (hprime < 5) {
345                        rgb[0] = sx;
346                        rgb[1] = sm;
347                        rgb[2] = sc;
348                } else if (hprime < 6) {
349                        rgb[0] = sc;
350                        rgb[1] = sm;
351                        rgb[2] = sx;
352                } else { // if hue is outside domain
353                        rgb[0] = sm;
354                        rgb[1] = sm;
355                        rgb[2] = sm;
356                }
357        }
358
359        private static void convertHSLToRGB(double h, double s, double l, short[] rgb) {
360                double m = l;
361                double chroma = s * (1 - Math.abs(2 * m - 1));
362                m -= chroma * 0.5;
363                m *= 255;
364                chroma *= 255;
365                double hprime = h / 60.;
366                if (hprime < 0) {
367                        hprime += 6;
368                }
369                short sx = (short) (chroma * (1 - Math.abs((hprime % 2) - 1)) + m);
370                short sc = (short) (chroma + m);
371                short sm = (short) m;
372                
373                if (hprime < 1) {
374                        rgb[0] = sc;
375                        rgb[1] = sx;
376                        rgb[2] = sm;
377                } else if (hprime < 2) {
378                        rgb[0] = sx;
379                        rgb[1] = sc;
380                        rgb[2] = sm;
381                } else if (hprime < 3) {
382                        rgb[0] = sm;
383                        rgb[1] = sc;
384                        rgb[2] = sx;
385                } else if (hprime < 4) {
386                        rgb[0] = sm;
387                        rgb[1] = sx;
388                        rgb[2] = sc;
389                } else if (hprime < 5) {
390                        rgb[0] = sx;
391                        rgb[1] = sm;
392                        rgb[2] = sc;
393                } else if (hprime < 6) {
394                        rgb[0] = sc;
395                        rgb[1] = sm;
396                        rgb[2] = sx;
397                } else { // if hue is outside domain
398                        rgb[0] = sm;
399                        rgb[1] = sm;
400                        rgb[2] = sm;
401                }
402        }
403
404        @Override
405        public RGBDataset getSlice(SliceIterator siter) {
406                CompoundShortDataset base = super.getSlice(siter);
407
408                RGBDataset slice = new RGBDataset();
409                copyToView(base, slice, false, false);
410                slice.setData();
411                return slice;
412        }
413
414        @Override
415        public RGBDataset getView(boolean deepCopyMetadata) {
416                RGBDataset view = new RGBDataset();
417                copyToView(this, view, true, deepCopyMetadata);
418                view.setData();
419                return view;
420        }
421
422        /**
423         * @return red value in the first position
424         * @since 2.0
425         */
426        public short getRed() {
427                return data[getFirst1DIndex()];
428        }
429
430        /**
431         * @param i
432         * @return red value in given position
433         */
434        public short getRed(final int i) {
435                return data[get1DIndex(i)];
436        }
437
438        /**
439         * @param i
440         * @param j
441         * @return red value in given position
442         */
443        public short getRed(final int i, final int j) {
444                return data[get1DIndex(i, j)];
445        }
446
447        /**
448         * @param pos
449         * @return red value in given position
450         */
451        public short getRed(final int... pos) {
452                return data[get1DIndex(pos)];
453        }
454
455        /**
456         * @return green value in the first position
457         * @since 2.0
458         */
459        public short getGreen() {
460                return data[getFirst1DIndex() + 1];
461        }
462
463        /**
464         * @param i
465         * @return green value in given position
466         */
467        public short getGreen(final int i) {
468                return data[get1DIndex(i) + 1];
469        }
470
471        /**
472         * @param i
473         * @param j
474         * @return green value in given position
475         */
476        public short getGreen(final int i, final int j) {
477                return data[get1DIndex(i, j) + 1];
478        }
479
480        /**
481         * @param pos
482         * @return green value in given position
483         */
484        public short getGreen(final int... pos) {
485                return data[get1DIndex(pos) + 1];
486        }
487
488        /**
489         * @return blue value in the first position
490         * @since 2.0
491         */
492        public short getBlue() {
493                return data[getFirst1DIndex() + 2];
494        }
495
496        /**
497         * @param i
498         * @return blue value in given position
499         */
500        public short getBlue(final int i) {
501                return data[get1DIndex(i) + 2];
502        }
503
504        /**
505         * @param i
506         * @param j
507         * @return blue value in given position
508         */
509        public short getBlue(final int i, final int j) {
510                return data[get1DIndex(i, j) + 2];
511        }
512
513        /**
514         * @param pos
515         * @return blue value in given position
516         */
517        public short getBlue(final int... pos) {
518                return data[get1DIndex(pos) + 2];
519        }
520
521        /**
522         * Get a red value from given absolute index as a short - note this index does not
523         * take in account the item size so be careful when using with multi-element items
524         * 
525         * @param n
526         * @return red value
527         */
528        public short getRedAbs(int n) {
529                return data[n*isize];
530        }
531
532        /**
533         * Get a green value from given absolute index as a short - note this index does not
534         * take in account the item size so be careful when using with multi-element items
535         * 
536         * @param n
537         * @return green value
538         */
539        public short getGreenAbs(int n) {
540                return data[n*isize + 1];
541        }
542
543        /**
544         * Get a blue value from given absolute index as a short - note this index does not
545         * take in account the item size so be careful when using with multi-element items
546         * 
547         * @param n
548         * @return blue value
549         */
550        public short getBlueAbs(int n) {
551                return data[n*isize + 2];
552        }
553
554
555        // weights from NTSC formula aka ITU-R BT.601 for mapping RGB to luma
556        private static final double Wr = 0.299, Wg = 0.587, Wb = 0.114;
557
558        /**
559         * Convert colour dataset to a grey-scale one using the NTSC formula, aka ITU-R BT.601, for RGB to luma mapping
560         * @param clazz
561         * @return a grey-scale dataset of given type
562         * @since 2.2
563         */
564        public <T extends Dataset> T createGreyDataset(final Class<T> clazz) {
565                return (T) createGreyDataset(clazz, Wr, Wg, Wb);
566        }
567
568        /**
569         * Convert colour dataset to a grey-scale one using given RGB to luma mapping
570         * @param clazz
571         * @param red weight
572         * @param green weight
573         * @param blue weight
574         * @return a grey-scale dataset of given class
575         * @since 2.2
576         */
577        @SuppressWarnings("unchecked")
578        public <T extends Dataset> T createGreyDataset(final Class<T> clazz, final double red, final double green, final double blue) {
579                return (T) createGreyDataset(red, green, blue, DTypeUtils.getDType(clazz));
580        }
581
582        /**
583         * Convert colour dataset to a grey-scale one using the NTSC formula, aka ITU-R BT.601, for RGB to luma mapping
584         * @param dtype
585         * @return a grey-scale dataset of given class
586         * @deprecated Use {@link RGBDataset#createGreyDataset(Class)}
587         */
588        @Deprecated
589        public Dataset createGreyDataset(final int dtype) {
590                return createGreyDataset(Wr, Wg, Wb, dtype);
591        }
592
593        /**
594         * Convert colour dataset to a grey-scale one using given RGB to luma mapping
595         * @param red weight
596         * @param green weight
597         * @param blue weight
598         * @param dtype
599         * @return a grey-scale dataset of given type
600         * @deprecated Use {@link RGBDataset#createGreyDataset(Class, double, double, double)}
601         */
602        @Deprecated
603        public Dataset createGreyDataset(final double red, final double green, final double blue, final int dtype) {
604                final Dataset grey = DatasetFactory.zeros(shape, dtype);
605                final IndexIterator it = getIterator();
606
607                int i = 0;
608                while (it.hasNext()) {
609                        grey.setObjectAbs(i++, red*data[it.index] + green*data[it.index + 1] + blue*data[it.index + 2]);
610                }
611                return grey;
612        }
613
614        /**
615         * Extract red colour channel
616         * @param clazz
617         * @return a dataset of given class
618         * @since 2.1
619         */
620        public <T extends Dataset> T createRedDataset(final T clazz) {
621                return createColourChannelDataset(0, clazz, "red");
622        }
623
624        /**
625         * Extract green colour channel
626         * @param clazz
627         * @return a dataset of given class
628         * @since 2.1
629         */
630        public <T extends Dataset> T createGreenDataset(final T clazz) {
631                return createColourChannelDataset(1, clazz, "green");
632        }
633
634        /**
635         * Extract blue colour channel
636         * @param clazz
637         * @return a dataset of given class
638         * @since 2.1
639         */
640        public <T extends Dataset> T createBlueDataset(final T clazz) {
641                return createColourChannelDataset(2, clazz, "blue");
642        }
643
644        /**
645         * Extract red colour channel
646         * @param dtype
647         * @return a dataset of given type
648         * @deprecated Use {@link #createRedDataset}
649         */
650        @Deprecated
651        public Dataset createRedDataset(final int dtype) {
652                return createColourChannelDataset(0, dtype, "red");
653        }
654
655        /**
656         * Extract green colour channel
657         * @param dtype
658         * @return a dataset of given type
659         * @deprecated Use {@link #createGreenDataset}
660         */
661        @Deprecated
662        public Dataset createGreenDataset(final int dtype) {
663                return createColourChannelDataset(1, dtype, "green");
664        }
665
666        /**
667         * Extract blue colour channel
668         * @param dtype
669         * @return a dataset of given type
670         * @deprecated Use {@link #createBlueDataset}
671         */
672        @Deprecated
673        public Dataset createBlueDataset(final int dtype) {
674                return createColourChannelDataset(2, dtype, "blue");
675        }
676
677        @SuppressWarnings("unchecked")
678        private <T extends Dataset> T createColourChannelDataset(int channelOffset, T clazz, String cName) {
679                return (T) createColourChannelDataset(channelOffset, DTypeUtils.getDType(clazz), cName);
680        }
681
682
683        @Deprecated
684        private Dataset createColourChannelDataset(final int channelOffset, final int dtype, final String cName) {
685                final Dataset channel = DatasetFactory.zeros(shape, dtype);
686
687                final StringBuilder cname = name == null ? new StringBuilder() : new StringBuilder(name);
688                if (cname.length() > 0) {
689                        cname.append('.');
690                }
691                cname.append(cName);
692                channel.setName(cname.toString());
693
694                final IndexIterator it = getIterator();
695
696                int i = 0;
697                while (it.hasNext()) {
698                        channel.setObjectAbs(i++, data[it.index + channelOffset]);
699                }
700
701                return channel;
702        }
703
704        /**
705         * @return red view
706         */
707        public ShortDataset getRedView() {
708                return getColourChannelView(0, "red");
709        }
710
711        /**
712         * @return green view
713         */
714        public ShortDataset getGreenView() {
715                return getColourChannelView(1, "green");
716        }
717
718        /**
719         * @return blue view
720         */
721        public ShortDataset getBlueView() {
722                return getColourChannelView(2, "blue");
723        }
724
725        private ShortDataset getColourChannelView(final int channelOffset, final String cName) {
726                ShortDataset view = getElements(channelOffset);
727                view.setName(cName);
728                return view;
729        }
730
731        @Override
732        public Number max(boolean... ignored) {
733                short max = Short.MIN_VALUE;
734                final IndexIterator it = getIterator();
735
736                while (it.hasNext()) {
737                        for (int i = 0; i < ISIZE; i++) {
738                                final short value = data[it.index + i];
739                                if (value > max)
740                                        max = value;
741                        }
742                }
743                return max;
744        }
745
746        @Override
747        public Number min(boolean... ignored) {
748                short max = Short.MAX_VALUE;
749                final IndexIterator it = getIterator();
750
751                while (it.hasNext()) {
752                        for (int i = 0; i < ISIZE; i++) {
753                                final short value = data[it.index + i];
754                                if (value < max)
755                                        max = value;
756                        }
757                }
758                return max;
759        }
760}