static VEC FullProf( // return full profile
const Image& img, // in
const MAT& shape, // in
int ipoint, // in: index of the current point
int fullproflen) // in
{
CV_Assert(fullproflen > 1 && fullproflen < 100); // 100 is arb
CV_Assert(fullproflen % 2 == 1); // fullprof length must be odd
VEC fullprof(1, fullproflen);
double xstep; // x axis dist corresponding to one pixel along whisker
double ystep;
WhiskerStep(xstep, ystep, shape, ipoint);
const double x = shape(ipoint, IX); // center point of the whisker
const double y = shape(ipoint, IY);
// number of pixs to sample in each direction along the whisker
const int n = (NSIZE(fullprof) - 1) / 2;
int prevpix = Pix(img,
Step(x, xstep, -n-1), Step(y, ystep, -n-1));
for (int i = -n; i <= n; i++)
{
const int pix = Pix(img,
Step(x, xstep, i), Step(y, ystep, i));
fullprof(i + n) = double(pix - prevpix); // signed gradient
prevpix = pix;
}
return fullprof;
}
Pix Pix::DitherToBinaryLUT(int lowerclip, int upperclip)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixDitherToBinaryLUT(pix, lowerclip, upperclip);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::DitherToBinaryLUT()
Pix Pix::ThresholdToValue(int threshval, int setval)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixThresholdToValue(NULL, pix, threshval, setval);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::ThresholdToValue()
Pix Pix::GrayQuantFromHisto(Pix &mPix, double minfract, int maxsize)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixGrayQuantFromHisto(NULL, pix, mPix, minfract, maxsize);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::GrayQuantFromHisto()
Pix Pix::GenerateMaskByDiscr32(unsigned refval1, unsigned refval2, int distflag)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixGenerateMaskByDiscr32(pix, refval1, refval2, distflag);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::GenerateMaskByDiscr32()
Pix Pix::GenerateMaskByValue(int val, bool useCMap)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixGenerateMaskByValue(pix, val, useCMap ? 1 : 0);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::GenerateMaskByValue()
Pix Pix::GenerateMaskByBand32(unsigned refval, int delm, int delp)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixGenerateMaskByBand32(pix, refval, delm, delp);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::GenerateMaskByBand32()
Pix Pix::ThresholdGrayArb(const char *edgevals, int outdepth, int use_average, int setblack, int setwhite)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixThresholdGrayArb(pix, edgevals, outdepth, use_average, setblack, setwhite);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::ThresholdGrayArb()
Pix Pix::ThresholdOn8bpp(int nlevels, int cmapflag)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixThresholdOn8bpp(pix, nlevels, cmapflag);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::ThresholdOn8bpp()
Pix Pix::DitherTo2bppSpec(int lowerclip, int upperclip, int cmapflag)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixDitherTo2bppSpec(pix, lowerclip, upperclip, cmapflag);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::DitherTo2bppSpec()
Pix Pix::GenerateMaskByBand(int lower, int upper, int inband, bool useCMap)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixGenerateMaskByBand(pix, lower, upper, inband, useCMap ? 1 : 0);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::GenerateMaskByBand()
Pix Pix::DitherTo2bpp(int cmapflag)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixDitherTo2bpp(pix, cmapflag);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::DitherTo2bpp()
static void SqrtErr (SingleGroup *x) {
int i, j;
for (j = 0; j < x->err.data.ny; j++) {
for (i = 0; i < x->err.data.nx; i++) {
Pix (x->err.data, i, j) = sqrt (Pix (x->err.data, i, j));
}
}
}
Pix Pix::VarThresholdToBinary(Pix &thresholdPix)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixVarThresholdToBinary(pix, thresholdPix);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::VarThresholdToBinary()
// threshold the image -- warning, operates ONLY on grayscale pixmaps
// original image is unchanged - a new modified image at raster's end
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
Pix Pix::ThresholdToBinary(int threshold)
{
if(IsEmpty())
return Pix();
PIX *dPix = pixThresholdToBinary(pix, threshold);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::ThresholdToBinary()
static void SquareErr (SingleGroup *x) {
int i, j;
for (j = 0; j < x->err.data.ny; j++) {
for (i = 0; i < x->err.data.nx; i++) {
Pix (x->err.data, i, j) =
Pix (x->err.data, i, j) * Pix (x->err.data, i, j);
}
}
}
NAMESPACE_UPP
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
Pix Pix::DitherToBinary()
{
if(IsEmpty())
return Pix();
PIX *dPix = pixDitherToBinary(pix);
if(!dPix)
return Pix();
return Pix(&dPix);
} // END Pix::DitherToBinary()
static int VMedianY (SingleGroup *in, int i, int *vy, short sdqflags,
double *median, double *scratch) {
/* arguments:
SingleGroup *in i: image to be calibrated
int i i: X pixel location in input image
int vy[2] i: range of pixel numbers in Y direction
double *median o: median of values in column
double scratch[] io: scratch space
*/
int j; /* loop indices */
int nvals; /* number of good pixels */
int inplace = 1; /* OK to sort in-place */
double MedianDouble (double *, int, int);
nvals = 0;
for (j = vy[0]; j < vy[1]; j++) {
if (DQPix (in->dq.data, i, j) == GOODPIXEL ||
!(DQPix (in->dq.data, i, j) & sdqflags)) {
scratch[nvals] = Pix (in->sci.data, i, j);
nvals++;
}
}
if (nvals < 1)
return (NO_GOOD_DATA);
*median = MedianDouble (scratch, nvals, inplace);
return (0);
}
Pix BaseDLList::ins_after(Pix p, const void *datum) {
if (p == 0) return prepend(datum);
BaseDLNode* u = (BaseDLNode*) p;
BaseDLNode* t = copy_node(datum);
t->bk = u;
t->fd = u->fd;
u->fd->bk = t;
u->fd = t;
return Pix(t);
}
int BaseDLList::owns(Pix p) const {
BaseDLNode* t = h;
if (t != 0 && p != 0) {
do {
if (Pix(t) == p) return 1;
t = t->fd;
} while (t != h);
}
return 0;
}
/* remove amplifier cross-talk */
void cross_talk_corr(ACSInfo *acs, SingleGroup *im) {
/* iteration variables */
int i, j;
/* cross talk scaling constant */
double cross_scale = 9.1e-5;
double temp;
const int arr_rows = im->sci.data.ny;
const int arr_cols = im->sci.data.nx;
for (i = 0; i < arr_rows; i++) {
for (j = 0; j < arr_cols; j++) {
temp = Pix(im->sci.data, arr_cols-j-1, i) * cross_scale;
Pix(im->sci.data, j, i) += (float) temp;
}
}
}
Pix BaseDLList::ins_before(Pix p, const void *datum) {
if (p == 0) error("null Pix");
BaseDLNode* u = (BaseDLNode*) p;
BaseDLNode* t = copy_node(datum);
t->bk = u->bk;
t->fd = u;
u->bk->fd = t;
u->bk = t;
if (u == h) h = t;
return Pix(t);
}
Pix BaseDLList::append(const void *datum) {
BaseDLNode* t = copy_node(datum);
if(t==0) DBG();
if (h == 0)
t->fd = t->bk = h = t;
else {
t->bk = h->bk;
t->bk->fd = t;
t->fd = h;
h->bk = t;
}
return Pix(t);
}
static int RptSumLine (SingleGroup *a, int line, SingleGroupLine *b) {
/* arguments:
SingleGroup *a io: input data; output sum
int line i: line from input/output to be summed
SingleGroupLine *b i: second input data line
*/
extern int status;
int i;
short dqa, dqb, dqab; /* data quality for a, b, combined */
if (a->sci.data.nx != b->sci.tot_nx)
return (status = SIZE_MISMATCH);
/* science data */
for (i = 0; i < a->sci.data.nx; i++) {
Pix (a->sci.data, i, line) = Pix(a->sci.data, i, line) + b->sci.line[i];
}
/* error array (actually contains variance) */
for (i = 0; i < a->err.data.nx; i++) {
Pix (a->err.data, i, line) = Pix (a->err.data, i, line) + b->err.line[i];
}
/* data quality */
for (i = 0; i < a->dq.data.nx; i++) {
dqa = DQPix (a->dq.data, i, line);
dqb = b->dq.line[i];
dqab = dqa | dqb;
DQSetPix (a->dq.data, i, line, dqab);
}
return (status);
}
void BaseDLList::del(Pix& p, int dir) {
if (p == 0) error("null Pix");
BaseDLNode* t = (BaseDLNode*) p;
if (t->fd == t) {
h = 0;
p = 0;
} else {
if (dir < 0) {
if (t == h)
p = 0;
else
p = Pix(t->bk);
} else {
if (t == h->bk)
p = 0;
else
p = Pix(t->fd);
}
t->bk->fd = t->fd;
t->fd->bk = t->bk;
if (t == h) h = t->fd;
}
delete_node(t);
}
TArray<uint8_t> CreatePalettedPixels(int conversion) override
{
TArray<uint8_t> Pix(512, true);
if (conversion == luminance)
{
memcpy(Pix.Data(), Pixels, 512);
}
else
{
// Since this presents itself to the game as a regular named texture
// it can easily be used on walls and flats and should work as such,
// even if it makes little sense.
for (int i = 0; i < 512; i++)
{
Pix[i] = ImageHelpers::GrayMap[Pixels[i]];
}
}
return Pix;
}
int findPreScanBias(SingleGroup *raz, float *mean, float *sigma){
/** this calls resistmean, which does a better job clipping outlying pixels
that just a standard stddev clip single pass*/
extern int status;
int i,j,k; /*Looping variables */
float plist[55377]; /*bias pixels to measure*/
float min=0.0;
float max=0.0;
float rmean;
float rsigma;
float sigreg =7.5; /*sigma clip*/
int subcol = RAZ_COLS/4;
int npix=0; /*track array size for resistant mean*/
rmean=0.;
rsigma=0.;
/*init plist*/
for (i=0;i<55377;i++){
plist[i]=0.;
}
for (k=1;k<=4;k++){ /*for each quadrance cdab*/
npix=0;
for (i=5;i<25; i++){ /*specific area fr post scan bias pixels*/
for (j=0; j<2051; j++){
if (npix < 55377 ){
plist[npix] = Pix(raz->sci.data,i+(k-1)*subcol,j);
npix+=1;
}
}
}
resistmean(plist, npix, sigreg, &rmean, &rsigma, &min, &max);
mean[k]= rmean;
sigma[k] = rsigma;
}
return status;
}
int findPostScanBias(SingleGroup *raz, float *mean, float *sigma){
extern int status;
int i,j,k; /*Looping variables */
float plist[55377]; /*bias bpixels to measure*/
float min=0.0;
float max=0.0;
float rmean=0.0;
float rsigma=0.0;
float sigreg =7.5; /*sigma clip*/
int subcol = RAZ_COLS/4;
int npix=0; /*track array size for resistant mean*/
/*init plist*/
for (i=0;i<55377;i++){
plist[i]=0.;
}
for (k=1;k<=4;k++){ /*for each quadrant cdab = 0123*/
npix=0;
for (i=RAZ_ROWS+5;i<= subcol-1; i++){ /*specific area for post scan bias pixels*/
for (j=0; j<2051; j++){
if (npix < 55377){
plist[npix] = Pix(raz->sci.data,i+(k-1)*subcol,j);
npix+=1;
}
}
}
resistmean(plist, npix, sigreg, &rmean, &rsigma, &min, &max);
mean[k]= rmean;
sigma[k] = rsigma;
}
return status;
}
/*
* unmake_amp_array does the opposite of make_amp_array, it takes amp array
* views and puts them back into the single group in the right order.
*/
static int unmake_amp_array(const int arr_rows, const int arr_cols, SingleGroup *im,
int amp, double * array) {
extern int status;
/* iteration variables */
int i, j;
/* variables for the image row/column we want */
int r,c;
for (i = 0; i < arr_rows; i++) {
for (j = 0; j < arr_cols; j++) {
if (amp == AMP_A) {
r = im->sci.data.ny - i - 1;
c = j;
} else if (amp == AMP_B) {
r = im->sci.data.ny - i - 1;
c = im->sci.data.nx - j - 1;
} else if (amp == AMP_C) {
r = i;
c = j;
} else if (amp == AMP_D) {
r = i;
c = im->sci.data.nx - j -1;
} else {
trlerror("Amp number not recognized, must be 0-3.");
status = ERROR_RETURN;
return status;
}
Pix(im->sci.data, c, r) = (float) array[i*arr_cols + j];
}
}
return status;
}
int sub2d (SingleGroup *a, SingleGroup *b) {
/* arguments:
SingleGroup *a io: input data; output difference
SingleGroup *b i: second input data
*/
int i, j;
float da, db; /* errors for a and b */
short dqa, dqb, dqab; /* data quality for a, b, combined */
if (a->sci.data.nx != b->sci.data.nx ||
a->sci.data.ny != b->sci.data.ny)
return (SIZE_MISMATCH);
/* science data */
for (j = 0; j < a->sci.data.ny; j++) {
for (i = 0; i < a->sci.data.nx; i++) {
Pix (a->sci.data, i, j) =
Pix (a->sci.data, i, j) - Pix (b->sci.data, i, j);
}
}
/* error array */
for (j = 0; j < a->err.data.ny; j++) {
for (i = 0; i < a->err.data.nx; i++) {
da = Pix (a->err.data, i, j);
db = Pix (b->err.data, i, j);
Pix (a->err.data, i, j) = sqrt (da * da + db * db);
}
}
/* data quality */
for (j = 0; j < a->dq.data.ny; j++) {
for (i = 0; i < a->dq.data.nx; i++) {
dqa = DQPix (a->dq.data, i, j);
dqb = DQPix (b->dq.data, i, j);
dqab = dqa | dqb;
DQSetPix (a->dq.data, i, j, dqab);
}
}
return (0);
}