boofcv.alg.misc.impl.ImplImageStatistics_MT Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of boofcv-ip Show documentation
Show all versions of boofcv-ip Show documentation
BoofCV is an open source Java library for real-time computer vision and robotics applications.
/*
* Copyright (c) 2023, Peter Abeles. All Rights Reserved.
*
* This file is part of BoofCV (http://boofcv.org).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package boofcv.alg.misc.impl;
import boofcv.struct.image.*;
import javax.annotation.Generated;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import boofcv.concurrency.BoofConcurrency;
/**
* Computes statistical properties of pixels inside an image.
*
*
* DO NOT MODIFY. Automatically generated code created by GenerateImplImageStatistics
*
* @author Peter Abeles
*/
@Generated("boofcv.alg.misc.impl.ImplImageStatistics")
public class ImplImageStatistics_MT {
public static int minU( byte[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex]& 0xFF;
return BoofConcurrency.min(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] & 0xFF;
if( v < output )
output = v;
}
return output;}).intValue();
}
public static int maxU( byte[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex]& 0xFF;
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] & 0xFF;
if( v > output )
output = v;
}
return output;}).intValue();
}
public static int maxAbsU( byte[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex]& 0xFF;
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] & 0xFF;
if( v > output )
output = v;
}
return output;}).intValue();
}
public static double meanDiffSqU(byte []dataA, int startIndexA , int strideA,
byte []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA]& 0xFF)-(dataB[indexB]& 0xFF);
total += difference*difference;
}
return total;}).intValue()/ (double)(rows*columns);
}
public static double meanDiffAbsU(byte []dataA, int startIndexA , int strideA,
byte []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA]& 0xFF)-(dataB[indexB]& 0xFF);
total += Math.abs(difference);
}
return total;}).intValue()/ (double)(rows*columns);
}
public static int sum( GrayU8 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] & 0xFF;
}
return total;}).intValue();
}
public static int sum( InterleavedU8 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] & 0xFF;
}
return total;}).intValue();
}
public static double variance( GrayU8 img , double mean ) {
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
double d = (img.data[index]& 0xFF) - mean;
total += d*d;
}
return total;}).intValue()/(img.width*img.height);
}
public static void histogram( GrayU8 input , int minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(input.data[index++]& 0xFF) - minValue ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayU8 input , int minValue , int maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final int histLength = histogram.length;
final int rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*((input.data[index++]& 0xFF) - minValue)/rangeValue) ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static int min( byte[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.min(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] ;
if( v < output )
output = v;
}
return output;}).intValue();
}
public static int max( byte[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] ;
if( v > output )
output = v;
}
return output;}).intValue();
}
public static int maxAbs( byte[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = Math.abs(array[index]);
if( v > output )
output = v;
}
return output;}).intValue();
}
public static double meanDiffSq(byte []dataA, int startIndexA , int strideA,
byte []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA])-(dataB[indexB]);
total += difference*difference;
}
return total;}).intValue()/ (double)(rows*columns);
}
public static double meanDiffAbs(byte []dataA, int startIndexA , int strideA,
byte []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA])-(dataB[indexB]);
total += Math.abs(difference);
}
return total;}).intValue()/ (double)(rows*columns);
}
public static int sum( GrayS8 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).intValue();
}
public static int sumAbs( GrayS8 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).intValue();
}
public static int sum( InterleavedS8 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).intValue();
}
public static int sumAbs( InterleavedS8 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).intValue();
}
public static double variance( GrayS8 img , double mean ) {
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
double d = (img.data[index]) - mean;
total += d*d;
}
return total;}).intValue()/(img.width*img.height);
}
public static void histogram( GrayS8 input , int minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(input.data[index++]) - minValue ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayS8 input , int minValue , int maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final int histLength = histogram.length;
final int rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*((input.data[index++]) - minValue)/rangeValue) ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static int minU( short[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex]& 0xFFFF;
return BoofConcurrency.min(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] & 0xFFFF;
if( v < output )
output = v;
}
return output;}).intValue();
}
public static int maxU( short[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex]& 0xFFFF;
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] & 0xFFFF;
if( v > output )
output = v;
}
return output;}).intValue();
}
public static int maxAbsU( short[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex]& 0xFFFF;
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] & 0xFFFF;
if( v > output )
output = v;
}
return output;}).intValue();
}
public static double meanDiffSqU(short []dataA, int startIndexA , int strideA,
short []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA]& 0xFFFF)-(dataB[indexB]& 0xFFFF);
total += difference*difference;
}
return total;}).intValue()/ (double)(rows*columns);
}
public static double meanDiffAbsU(short []dataA, int startIndexA , int strideA,
short []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA]& 0xFFFF)-(dataB[indexB]& 0xFFFF);
total += Math.abs(difference);
}
return total;}).intValue()/ (double)(rows*columns);
}
public static int sum( GrayU16 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] & 0xFFFF;
}
return total;}).intValue();
}
public static int sum( InterleavedU16 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] & 0xFFFF;
}
return total;}).intValue();
}
public static double variance( GrayU16 img , double mean ) {
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
double d = (img.data[index]& 0xFFFF) - mean;
total += d*d;
}
return total;}).intValue()/(img.width*img.height);
}
public static void histogram( GrayU16 input , int minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(input.data[index++]& 0xFFFF) - minValue ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayU16 input , int minValue , int maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final int histLength = histogram.length;
final int rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*((input.data[index++]& 0xFFFF) - minValue)/rangeValue) ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static int min( short[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.min(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] ;
if( v < output )
output = v;
}
return output;}).intValue();
}
public static int max( short[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] ;
if( v > output )
output = v;
}
return output;}).intValue();
}
public static int maxAbs( short[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = Math.abs(array[index]);
if( v > output )
output = v;
}
return output;}).intValue();
}
public static double meanDiffSq(short []dataA, int startIndexA , int strideA,
short []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA])-(dataB[indexB]);
total += difference*difference;
}
return total;}).intValue()/ (double)(rows*columns);
}
public static double meanDiffAbs(short []dataA, int startIndexA , int strideA,
short []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA])-(dataB[indexB]);
total += Math.abs(difference);
}
return total;}).intValue()/ (double)(rows*columns);
}
public static int sum( GrayS16 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).intValue();
}
public static int sumAbs( GrayS16 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).intValue();
}
public static int sum( InterleavedS16 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).intValue();
}
public static int sumAbs( InterleavedS16 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).intValue();
}
public static double variance( GrayS16 img , double mean ) {
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
double d = (img.data[index]) - mean;
total += d*d;
}
return total;}).intValue()/(img.width*img.height);
}
public static void histogram( GrayS16 input , int minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(input.data[index++]) - minValue ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayS16 input , int minValue , int maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final int histLength = histogram.length;
final int rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*((input.data[index++]) - minValue)/rangeValue) ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static int min( int[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.min(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] ;
if( v < output )
output = v;
}
return output;}).intValue();
}
public static int max( int[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = array[index] ;
if( v > output )
output = v;
}
return output;}).intValue();
}
public static int maxAbs( int[] array , int startIndex , int rows , int columns , int stride ) {
final int _output = array[startIndex];
return BoofConcurrency.max(0,rows,int.class,y->{
int output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
int v = Math.abs(array[index]);
if( v > output )
output = v;
}
return output;}).intValue();
}
public static double meanDiffSq(int []dataA, int startIndexA , int strideA,
int []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA])-(dataB[indexB]);
total += difference*difference;
}
return total;}).intValue()/ (double)(rows*columns);
}
public static double meanDiffAbs(int []dataA, int startIndexA , int strideA,
int []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,int.class,y->{
int total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
int difference = (dataA[indexA])-(dataB[indexB]);
total += Math.abs(difference);
}
return total;}).intValue()/ (double)(rows*columns);
}
public static int sum( GrayS32 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).intValue();
}
public static int sumAbs( GrayS32 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).intValue();
}
public static int sum( InterleavedS32 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).intValue();
}
public static int sumAbs( InterleavedS32 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,int.class,y->{
int total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).intValue();
}
public static double variance( GrayS32 img , double mean ) {
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
double d = (img.data[index]) - mean;
total += d*d;
}
return total;}).intValue()/(img.width*img.height);
}
public static void histogram( GrayS32 input , int minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(input.data[index++]) - minValue ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayS32 input , int minValue , int maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final int histLength = histogram.length;
final int rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*((input.data[index++]) - minValue)/rangeValue) ]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static long min( long[] array , int startIndex , int rows , int columns , int stride ) {
final long _output = array[startIndex];
return BoofConcurrency.min(0,rows,long.class,y->{
long output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
long v = array[index] ;
if( v < output )
output = v;
}
return output;}).longValue();
}
public static long max( long[] array , int startIndex , int rows , int columns , int stride ) {
final long _output = array[startIndex];
return BoofConcurrency.max(0,rows,long.class,y->{
long output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
long v = array[index] ;
if( v > output )
output = v;
}
return output;}).longValue();
}
public static long maxAbs( long[] array , int startIndex , int rows , int columns , int stride ) {
final long _output = array[startIndex];
return BoofConcurrency.max(0,rows,long.class,y->{
long output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
long v = Math.abs(array[index]);
if( v > output )
output = v;
}
return output;}).longValue();
}
public static double meanDiffSq(long []dataA, int startIndexA , int strideA,
long []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,long.class,y->{
long total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
long difference = (dataA[indexA])-(dataB[indexB]);
total += difference*difference;
}
return total;}).longValue()/ (double)(rows*columns);
}
public static double meanDiffAbs(long []dataA, int startIndexA , int strideA,
long []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,long.class,y->{
long total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
long difference = (dataA[indexA])-(dataB[indexB]);
total += Math.abs(difference);
}
return total;}).longValue()/ (double)(rows*columns);
}
public static long sum( GrayS64 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,long.class,y->{
long total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).longValue();
}
public static long sumAbs( GrayS64 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,long.class,y->{
long total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).longValue();
}
public static long sum( InterleavedS64 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,long.class,y->{
long total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).longValue();
}
public static long sumAbs( InterleavedS64 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,long.class,y->{
long total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).longValue();
}
public static double variance( GrayS64 img , double mean ) {
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
double d = (img.data[index]) - mean;
total += d*d;
}
return total;}).longValue()/(img.width*img.height);
}
public static void histogram( GrayS64 input , long minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(input.data[index++] - minValue)]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayS64 input , long minValue , long maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final long histLength = histogram.length;
final long rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*(input.data[index++] - minValue)/rangeValue)]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static float min( float[] array , int startIndex , int rows , int columns , int stride ) {
final float _output = array[startIndex];
return BoofConcurrency.min(0,rows,float.class,y->{
float output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
float v = array[index] ;
if( v < output )
output = v;
}
return output;}).floatValue();
}
public static float max( float[] array , int startIndex , int rows , int columns , int stride ) {
final float _output = array[startIndex];
return BoofConcurrency.max(0,rows,float.class,y->{
float output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
float v = array[index] ;
if( v > output )
output = v;
}
return output;}).floatValue();
}
public static float maxAbs( float[] array , int startIndex , int rows , int columns , int stride ) {
final float _output = array[startIndex];
return BoofConcurrency.max(0,rows,float.class,y->{
float output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
float v = Math.abs(array[index]);
if( v > output )
output = v;
}
return output;}).floatValue();
}
public static double meanDiffSq(float []dataA, int startIndexA , int strideA,
float []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,float.class,y->{
float total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
float difference = (dataA[indexA])-(dataB[indexB]);
total += difference*difference;
}
return total;}).floatValue()/ (double)(rows*columns);
}
public static double meanDiffAbs(float []dataA, int startIndexA , int strideA,
float []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,float.class,y->{
float total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
float difference = (dataA[indexA])-(dataB[indexB]);
total += Math.abs(difference);
}
return total;}).floatValue()/ (double)(rows*columns);
}
public static float sum( GrayF32 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,float.class,y->{
float total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).floatValue();
}
public static float sumAbs( GrayF32 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,float.class,y->{
float total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).floatValue();
}
public static float sum( InterleavedF32 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,float.class,y->{
float total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).floatValue();
}
public static float sumAbs( InterleavedF32 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,float.class,y->{
float total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).floatValue();
}
public static float variance( GrayF32 img , float mean ) {
return BoofConcurrency.sum(0,img.height,float.class,y->{
float total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
float d = (img.data[index]) - mean;
total += d*d;
}
return total;}).floatValue()/(img.width*img.height);
}
public static void histogram( GrayF32 input , float minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(input.data[index++] - minValue)]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayF32 input , float minValue , float maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final float histLength = histogram.length;
final float rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*(input.data[index++] - minValue)/rangeValue)]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static double min( double[] array , int startIndex , int rows , int columns , int stride ) {
final double _output = array[startIndex];
return BoofConcurrency.min(0,rows,double.class,y->{
double output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
double v = array[index] ;
if( v < output )
output = v;
}
return output;}).doubleValue();
}
public static double max( double[] array , int startIndex , int rows , int columns , int stride ) {
final double _output = array[startIndex];
return BoofConcurrency.max(0,rows,double.class,y->{
double output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
double v = array[index] ;
if( v > output )
output = v;
}
return output;}).doubleValue();
}
public static double maxAbs( double[] array , int startIndex , int rows , int columns , int stride ) {
final double _output = array[startIndex];
return BoofConcurrency.max(0,rows,double.class,y->{
double output = _output;
int index = startIndex + y*stride;
int end = index + columns;
for( ; index < end; index++ ) {
double v = Math.abs(array[index]);
if( v > output )
output = v;
}
return output;}).doubleValue();
}
public static double meanDiffSq(double []dataA, int startIndexA , int strideA,
double []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,double.class,y->{
double total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
double difference = (dataA[indexA])-(dataB[indexB]);
total += difference*difference;
}
return total;}).doubleValue()/ (double)(rows*columns);
}
public static double meanDiffAbs(double []dataA, int startIndexA , int strideA,
double []dataB, int startIndexB , int strideB,
int rows , int columns ) {
return BoofConcurrency.sum(0,rows,double.class,y->{
double total = 0;
int indexA = startIndexA + y * strideA;
int indexB = startIndexB + y * strideB;
int indexEnd = indexA+columns;
for (; indexA < indexEnd; indexA++,indexB++) {
double difference = (dataA[indexA])-(dataB[indexB]);
total += Math.abs(difference);
}
return total;}).doubleValue()/ (double)(rows*columns);
}
public static double sum( GrayF64 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).doubleValue();
}
public static double sumAbs( GrayF64 img ) {
final int rows = img.height;
final int columns = img.width;
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).doubleValue();
}
public static double sum( InterleavedF64 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += img.data[index] ;
}
return total;}).doubleValue();
}
public static double sumAbs( InterleavedF64 img ) {
final int rows = img.height;
final int columns = img.width*img.numBands;
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.startIndex + y * img.stride;
int indexEnd = index+columns;
for (; index < indexEnd; index++ ) {
total += Math.abs(img.data[index] );
}
return total;}).doubleValue();
}
public static double variance( GrayF64 img , double mean ) {
return BoofConcurrency.sum(0,img.height,double.class,y->{
double total = 0;
int index = img.getStartIndex() + y * img.getStride();
int indexEnd = index+img.width;
// for(int x = 0; x < img.width; x++ ) {
for (; index < indexEnd; index++ ) {
double d = (img.data[index]) - mean;
total += d*d;
}
return total;}).doubleValue()/(img.width*img.height);
}
public static void histogram( GrayF64 input , double minValue , int[] histogram ) {
Arrays.fill(histogram,0);
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(input.data[index++] - minValue)]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
public static void histogramScaled( GrayF64 input , double minValue , double maxValue, int[] histogram ) {
Arrays.fill(histogram,0);
final double histLength = histogram.length;
final double rangeValue = maxValue-minValue+1;
final List list = new ArrayList<>();
BoofConcurrency.loopBlocks(0,input.height,(y0,y1)->{
final int[] h = new int[histogram.length];
for( int y = y0; y < y1; y++ ) {
int index = input.startIndex + y*input.stride;
int end = index + input.width;
while( index < end ) {
h[(int)(histLength*(input.data[index++] - minValue)/rangeValue)]++;
}
}
synchronized(list){list.add(h);}});
for (int i = 0; i < list.size(); i++) {
int[] h = list.get(i);
for (int j = 0; j < histogram.length; j++) {
histogram[j] += h[j];
}
}
}
}