/*!
* \return New grey value domain object with incrementing values.
* \ingroup WlzValuesUtils
* \brief Creates a new 2D domain object with integer values that
* increment throughout the object in scan order. Object
* values are set by incrementing the given value in place.
* \param in Input domain object.
* \param val Pointer to current value, this is
* incremented in place.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzGreyNewIncValues2D(WlzObject *in, int *val,
WlzErrorNum *dstErr)
{
WlzObject *out = NULL;
WlzObjectType gTT;
WlzPixelV bgd;
WlzValues values;
WlzErrorNum errNum = WLZ_ERR_NONE;
bgd.type = WLZ_GREY_INT;
bgd.v.inv = 0;
values.core = NULL;
gTT = WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_INT, &errNum);
if(errNum == WLZ_ERR_NONE)
{
values.v = WlzNewValueTb(in, gTT, bgd, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
out = WlzMakeMain(in->type, in->domain, values, in->plist, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzGreySetIncValuesItr(out, val);
}
if(errNum != WLZ_ERR_NONE)
{
if(out != NULL)
{
(void )WlzFreeObj(out);
out = NULL;
}
else if(values.core != NULL)
{
(void )WlzFreeValues(values);
}
}
if(dstErr != NULL)
{
*dstErr = errNum;
}
return(out);
}
/*!
* \ingroup WlzValuesUtils
* \brief
*
* \return New object with the same domain <tt>tmpl</tt> but
values in the intersection with <tt>obj</tt> set to those of the object.
Returns NULL on error.
* \param obj Input object to which the template is applied
* \param tmpl Template object
* \param tmplVal Template value for regions in the template
not in the original object
* \param dstErr Error return.
* \par Source:
* WlzGreyTemplate.c
*/
WlzObject *WlzGreyTemplate(
WlzObject *obj,
WlzObject *tmpl,
WlzPixelV tmplVal,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzObject *obj1, *obj2;
WlzValues values;
WlzPixelV bckgrnd;
WlzObjectType type;
WlzGreyType gtype=WLZ_GREY_UBYTE;
WlzIntervalWSpace iwsp1, iwsp2;
WlzGreyWSpace gwsp1, gwsp2;
int size;
WlzErrorNum errNum = WLZ_ERR_NONE;
/* check obj */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( WlzGreyTableIsTiled(obj->values.core->type) ){
errNum = WLZ_ERR_VALUES_TYPE;
} else {
bckgrnd = WlzGetBackground(obj, &errNum);
}
if(errNum == WLZ_ERR_NONE) {
gtype = WlzGreyTableTypeToGreyType(obj->values.core->type, NULL);
}
break;
case WLZ_3D_DOMAINOBJ:
return WlzGreyTemplate3d(obj, tmpl, tmplVal, dstErr);
case WLZ_TRANS_OBJ:
if((values.obj = WlzGreyTemplate(obj->values.obj, tmpl,
tmplVal, &errNum)) != NULL){
return WlzMakeMain(WLZ_TRANS_OBJ, obj->domain, values,
NULL, NULL, dstErr);
}
break;
case WLZ_EMPTY_OBJ:
bckgrnd.type = WLZ_GREY_UBYTE;
bckgrnd.v.ubv = 0;
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* check the template */
if( errNum == WLZ_ERR_NONE ){
if( tmpl == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
values.core = NULL;
switch( tmpl->type ){
case WLZ_2D_DOMAINOBJ:
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, tmpl->domain, values,
NULL, NULL, &errNum);
break;
case WLZ_TRANS_OBJ:
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, tmpl->values.obj->domain,
values, NULL, NULL, &errNum);
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
case WLZ_2D_POLYGON:
rtnObj = WlzPolyToObj(tmpl->domain.poly, WLZ_SIMPLE_FILL, &errNum);
break;
case WLZ_BOUNDLIST:
rtnObj = WlzBoundToObj(tmpl->domain.b, WLZ_SIMPLE_FILL, &errNum);
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
}
/* attach a value table to the template and set to the template value,
note the background is set to the input object or zero if empty */
if( errNum == WLZ_ERR_NONE ){
type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gtype, NULL);
if((values.v = WlzNewValueTb(rtnObj, type, bckgrnd, &errNum)) != NULL){
rtnObj->values = WlzAssignValues(values, NULL);
errNum = WlzGreySetValue(rtnObj, tmplVal);
}
}
/* copy input obj values within the intersection */
if( errNum == WLZ_ERR_NONE ){
if((obj->type != WLZ_EMPTY_OBJ) ){
if( (obj1 = WlzIntersect2(obj, rtnObj, &errNum)) ){
obj1->values = WlzAssignValues(rtnObj->values, NULL);
obj2 = WlzMakeMain(obj1->type, obj1->domain, obj->values,
NULL, NULL, NULL);
errNum = WlzInitGreyScan(obj1, &iwsp1, &gwsp1);
errNum = WlzInitGreyScan(obj2, &iwsp2, &gwsp2);
switch( gwsp1.pixeltype ){
case WLZ_GREY_INT:
size = sizeof(int);
break;
case WLZ_GREY_SHORT:
size = sizeof(short);
break;
case WLZ_GREY_UBYTE:
size = sizeof(WlzUByte);
break;
case WLZ_GREY_FLOAT:
size = sizeof(float);
break;
case WLZ_GREY_DOUBLE:
size = sizeof(double);
break;
case WLZ_GREY_RGBA:
size = sizeof(WlzUInt);
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp1)) == WLZ_ERR_NONE)){
(void) WlzNextGreyInterval(&iwsp2);
memcpy((void *) gwsp1.u_grintptr.inp,
(const void *) gwsp2.u_grintptr.inp,
size * iwsp1.colrmn);
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
WlzFreeObj(obj2);
WlzFreeObj(obj1);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \ingroup WlzBinaryOps
* \brief Calculate the set union of an array of domain objects.
Domians only unless uvt non-zero in which case make an average grey
table. Note background values are used in the averaging process. All
objects must be domain objects of the same type (2D or 3D) unless
WLZ_EMPTY_OBJ, NULL input objects are an error.
This function may modify the order of the objects in the array it is
passed if the array contains empty objects.
*
* \return Union of the array of object.
* \param n number of input objects
* \param objs input object array
* \param uvt grey-table copy flag, copy if non-zero.
* \param dstErr error return.
* \par Source:
* WlzUnionN.c
*/
WlzObject *WlzUnionN(
int n,
WlzObject **objs,
int uvt,
WlzErrorNum *dstErr)
{
WlzObject *obj=NULL;
WlzDomain domain;
WlzValues values;
WlzIntervalDomain *idom;
WlzInterval *itvl, *jtvl;
WlzIntervalWSpace *iwsp;
WlzIntervalWSpace *biwsp, *tiwsp, niwsp;
WlzGreyWSpace *gwsp, ngwsp;
WlzObjectType type;
int i, j, k, l;
int inttot, numactive, change, lwas, nints, noverlap;
WlzPixelV backg;
int line1, lastln;
int kol1,lastkl;
WlzGreyV gv;
WlzGreyP greyptr;
int **locbuff;
int *locbuffs;
int span;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* preliminary stuff - count of non-NULL objects, note WLZ_EMPTY_OBJs
are ignored but NULL objects are an error */
if( n < 1 ){
errNum = WLZ_ERR_PARAM_DATA;
}
else {
for (i=0; i<n ; i++ ){
if ( objs[i] == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
break;
}
if( objs[i]->type == WLZ_EMPTY_OBJ ){
obj = objs[i];
for ( j=i; j<n-1 ; j++ ){
objs[j] = objs[j+1];
}
objs[n-1] = obj;
n--;
i--;
}
}
}
/* n has been checked therefore no objects implies all empty */
if( (errNum == WLZ_ERR_NONE) && (n < 1) ){
return WlzMakeEmpty(dstErr);
}
/* now check they are all of the same type */
if( errNum == WLZ_ERR_NONE ){
for(i=1; i < n; i++){
if( objs[i]->type != objs[0]->type ){
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
}
/* now test the type note empty objects have been discarded */
if( errNum == WLZ_ERR_NONE ){
switch( objs[0]->type ){
case WLZ_2D_DOMAINOBJ:
break;
case WLZ_3D_DOMAINOBJ:
return WlzUnion3d(n, objs, uvt, dstErr);
case WLZ_TRANS_OBJ:
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* now discard empty objects */
if( errNum == WLZ_ERR_NONE ){
for (i=0; i<n ; i++ ){
if( WlzIsEmpty(objs[i], NULL) ){
obj = objs[i];
for ( j=i; j<n-1 ; j++ ){
objs[j] = objs[j+1];
}
objs[n-1] = obj;
n--;
i--;
}
}
}
obj = NULL;
/* recheck number of objects */
if( (errNum == WLZ_ERR_NONE) && (n < 1) ){
return WlzMakeEmpty(dstErr);
}
if( (errNum == WLZ_ERR_NONE) && (n == 1) ){
return WlzMakeMain(objs[0]->type, objs[0]->domain,
objs[0]->values, NULL, NULL, dstErr);
}
/* check if grey-value merge is possible */
if( errNum == WLZ_ERR_NONE ){
for (i=0; i<n ; i++ ){
if( objs[i]->values.core == NULL ){
uvt = 0;
break;
}
}
}
/*
* find the line and column bounds of the union.
*/
if( errNum == WLZ_ERR_NONE ){
line1 = objs[0]->domain.i->line1;
lastln = objs[0]->domain.i->lastln;
kol1 = objs[0]->domain.i->kol1;
lastkl = objs[0]->domain.i->lastkl;
for (i=1; i<n; i++) {
idom = objs[i]->domain.i;
if (line1 > idom->line1)
line1 = idom->line1;
if (lastln < idom->lastln)
lastln = idom->lastln;
if (kol1 > idom->kol1)
kol1 = idom->kol1;
if (lastkl < idom->lastkl)
lastkl = idom->lastkl;
}
span = lastkl - kol1 +1 ;
if( (locbuff = (int **) AlcMalloc((n+1)*sizeof(int *))) == NULL ){
errNum = WLZ_ERR_MEM_ALLOC;
}
}
/* space must be allocated for the largest variety of grey-value */
if( errNum == WLZ_ERR_NONE ){
if( (locbuffs = (int *) AlcMalloc(sizeof(double)*span*(n+1))) == NULL ){
AlcFree((void *) locbuff);
errNum = WLZ_ERR_MEM_ALLOC;
}
else {
for(i=0; i <= n; i++){
locbuff[i] = locbuffs + i*span;
}
}
}
/*
* count the individual intervals so that sufficient space
* for the union may be allocated.
*/
if( errNum == WLZ_ERR_NONE ){
inttot=0;
for(i=0; i < n; i++){
inttot += WlzIntervalCount(objs[i]->domain.i, &errNum);
}
}
/*
* set up domain, value table structures, and object.
*/
if( errNum == WLZ_ERR_NONE ){
if( (idom = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL,
line1,lastln,kol1,lastkl,
&errNum)) == NULL ){
AlcFree((void *) locbuffs);
AlcFree((void *) locbuff);
}
else if( (itvl = (WlzInterval *)
AlcMalloc(inttot * sizeof(WlzInterval))) == NULL){
AlcFree((void *) locbuffs);
AlcFree((void *) locbuff);
WlzFreeIntervalDomain(idom);
errNum = WLZ_ERR_MEM_ALLOC;
}
else {
idom->freeptr = AlcFreeStackPush(idom->freeptr, (void *)itvl, NULL);
lwas = line1;
jtvl = itvl;
nints = 0;
domain.i = idom;
values.v = NULL;
if( (obj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum)) == NULL ){
WlzFreeIntervalDomain( idom );
AlcFree((void *) locbuffs);
AlcFree((void *) locbuff);
return(NULL);
}
}
}
/*
* allocate space for workspaces
*/
if( errNum == WLZ_ERR_NONE ){
if( (iwsp = (WlzIntervalWSpace *)
AlcMalloc (n * sizeof (WlzIntervalWSpace))) == NULL ){
WlzFreeObj( obj );
AlcFree((void *) locbuffs);
AlcFree((void *) locbuff);
errNum = WLZ_ERR_MEM_ALLOC;
obj = NULL;
}
else {
biwsp = iwsp;
tiwsp = iwsp + n;
}
}
/*
* Construct the union object's table of intervals.
* Initialise scanning on each object/workspace combination.
* Scan synchronously, setting up the union of adjacent and
* overlapping intervals. Needs a clear head !!
*/
if( errNum == WLZ_ERR_NONE ){
for (i=0; i<n; i++) {
WlzInitRasterScan(objs[i], iwsp, WLZ_RASTERDIR_ILIC);
WlzNextInterval(iwsp++);
}
numactive = n;
/*
* find next line and left hand end of next interval of union
*/
while (numactive > 0) {
/*
* find first remaining active object
*/
iwsp = biwsp;
while( iwsp->linrmn < 0 ){
iwsp++;
}
/*
* find minimum line number of remaining active intervals
*/
l = iwsp->linpos;
kol1 = iwsp->lftpos;
lastkl = iwsp->rgtpos;
for (iwsp++; iwsp<tiwsp; iwsp++)
if (iwsp->linrmn >= 0 && iwsp->linpos < l) {
l = iwsp->linpos;
kol1 = iwsp->lftpos;
lastkl = iwsp->rgtpos;
}
/*
* find left-most interval in this line
*/
for (iwsp=biwsp; iwsp<tiwsp; iwsp++)
if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos < kol1) {
kol1 = iwsp->lftpos;
lastkl = iwsp->rgtpos;
}
/*
* construct maximal interval with current left end-point
*/
do {
change = 0;
for (iwsp=biwsp; iwsp<tiwsp; iwsp++) {
while( iwsp->linrmn >= 0 && iwsp->linpos == l
&& iwsp->lftpos <= lastkl+1 ){
if (iwsp->rgtpos > lastkl) {
lastkl = iwsp->rgtpos;
change = 1;
}
if (WlzNextInterval(iwsp) != WLZ_ERR_NONE) {
numactive--;
}
}
}
} while (change == 1);
itvl->ileft = kol1 - idom->kol1;
itvl->iright = lastkl - idom->kol1;
if (l == lwas)
nints++;
else {
(void) WlzMakeInterval(lwas,idom,nints,jtvl);
for (j = lwas+1; j<l; j++) {
(void) WlzMakeInterval(j,idom,0,NULL);
}
lwas = l;
nints = 1;
jtvl = itvl;
}
itvl++;
}
(void) WlzMakeInterval(lwas,idom,nints,jtvl);
for (j = lwas+1; j<=lastln; j++) {
(void) WlzMakeInterval(j,idom,0,NULL);
}
}
/* now deal with the grey-values if required */
if( (errNum == WLZ_ERR_NONE) && (uvt != 0) ){
WlzGreyType grey_type;
if( (gwsp = (WlzGreyWSpace *)
AlcMalloc (n * sizeof (WlzGreyWSpace))) == NULL){
WlzFreeObj( obj );
AlcFree((void *) locbuffs);
AlcFree((void *) locbuff);
AlcFree((void *) biwsp);
errNum = WLZ_ERR_MEM_ALLOC;
obj = NULL;
}
/* construct an empty "ragged-rectangle" greytable
with appropriate grey-type */
if( errNum == WLZ_ERR_NONE ){
backg = WlzGetBackground(objs[0], NULL);
grey_type = WlzGreyTableTypeToGreyType(objs[0]->values.core->type,
NULL);
type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, grey_type, NULL);
if( (values.v = WlzNewValueTb(obj, type, backg, &errNum)) == NULL ){
WlzFreeObj( obj );
AlcFree((void *) locbuffs);
AlcFree((void *) locbuff);
AlcFree((void *) biwsp);
obj = NULL;
}
else {
obj->values = WlzAssignValues(values, NULL);
}
}
/* fill the grey table. Where more than one input objects
overlap, take mean of grey values. */
if( errNum == WLZ_ERR_NONE ){
WlzInitGreyScan(obj, &niwsp, &ngwsp);
iwsp = biwsp;
for (i=0; i<n; i++) {
WlzInitGreyScan(objs[i], iwsp, &gwsp[i]);
WlzNextGreyInterval(iwsp++);
if( gwsp[i].pixeltype != grey_type ){
AlcFree((void *) gwsp);
AlcFree((void *) locbuffs);
AlcFree((void *) locbuff);
AlcFree((void *) biwsp);
WlzFreeObj( obj );
obj = NULL;
errNum = WLZ_ERR_GREY_TYPE;
}
}
}
if( errNum == WLZ_ERR_NONE ){
while (WlzNextGreyInterval(&niwsp) == WLZ_ERR_NONE) {
l = niwsp.linpos;
greyptr = ngwsp.u_grintptr;
switch( ngwsp.pixeltype ){
case WLZ_GREY_INT:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
noverlap = 0;
gv.inv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while (iwsp->linrmn >= 0
&& (iwsp->linpos < l
|| (iwsp->linpos == l && iwsp->rgtpos < k))){
WlzNextGreyInterval(iwsp);
}
if (iwsp->linrmn >= 0 && iwsp->linpos == l &&
iwsp->lftpos <= k) {
noverlap++;
gv.inv += *(gwsp[i].u_grintptr.inp + k - iwsp->lftpos);
}
}
*greyptr.inp = gv.inv / noverlap;
greyptr.inp++;
}
break;
case WLZ_GREY_SHORT:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
noverlap = 0;
gv.shv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while (iwsp->linrmn >= 0
&& (iwsp->linpos < l
|| (iwsp->linpos == l && iwsp->rgtpos < k))){
WlzNextGreyInterval(iwsp);
}
if (iwsp->linrmn >= 0 && iwsp->linpos == l &&
iwsp->lftpos <= k) {
noverlap++;
gv.shv += *(gwsp[i].u_grintptr.shp + k - iwsp->lftpos);
}
}
*greyptr.shp = (short )(gv.shv / noverlap);
greyptr.shp++;
}
break;
case WLZ_GREY_UBYTE:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
noverlap = 0;
gv.inv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while (iwsp->linrmn >= 0
&& (iwsp->linpos < l
|| (iwsp->linpos == l && iwsp->rgtpos < k))){
WlzNextGreyInterval(iwsp);
}
if (iwsp->linrmn >= 0 && iwsp->linpos == l &&
iwsp->lftpos <= k) {
noverlap++;
gv.inv += *(gwsp[i].u_grintptr.ubp + k - iwsp->lftpos);
}
}
*greyptr.ubp = (WlzUByte )(gv.inv / noverlap);
greyptr.ubp++;
}
break;
case WLZ_GREY_FLOAT:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
noverlap = 0;
gv.flv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while (iwsp->linrmn >= 0
&& (iwsp->linpos < l
|| (iwsp->linpos == l && iwsp->rgtpos < k))){
WlzNextGreyInterval(iwsp);
}
if (iwsp->linrmn >= 0 && iwsp->linpos == l &&
iwsp->lftpos <= k) {
noverlap++;
gv.flv += *(gwsp[i].u_grintptr.flp + k - iwsp->lftpos);
}
}
*greyptr.flp = gv.flv / noverlap;
greyptr.flp++;
}
break;
case WLZ_GREY_DOUBLE:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
noverlap = 0;
gv.dbv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while (iwsp->linrmn >= 0
&& (iwsp->linpos < l
|| (iwsp->linpos == l && iwsp->rgtpos < k))){
WlzNextGreyInterval(iwsp);
}
if (iwsp->linrmn >= 0 && iwsp->linpos == l &&
iwsp->lftpos <= k) {
noverlap++;
gv.dbv += *(gwsp[i].u_grintptr.dbp + k - iwsp->lftpos);
}
}
*greyptr.dbp = gv.dbv / noverlap;
greyptr.dbp++;
}
break;
case WLZ_GREY_RGBA: /* RGBA to be done - do properly RAB */
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
noverlap = 0;
gv.rgbv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while (iwsp->linrmn >= 0
&& (iwsp->linpos < l
|| (iwsp->linpos == l && iwsp->rgtpos < k))){
WlzNextGreyInterval(iwsp);
}
if (iwsp->linrmn >= 0 && iwsp->linpos == l &&
iwsp->lftpos <= k) {
noverlap++;
gv.rgbv += *(gwsp[i].u_grintptr.rgbp + k - iwsp->lftpos);
}
}
*greyptr.rgbp = gv.rgbv / noverlap;
greyptr.rgbp++;
}
break;
default:
break;
}
}
}
AlcFree((void *) gwsp);
}
if( errNum == WLZ_ERR_NONE ){
AlcFree( (void *) biwsp);
AlcFree( (void *)locbuff );
AlcFree( (void *)locbuffs );
}
if( dstErr ){
*dstErr = errNum;
}
return( obj );
}
/*!
* \return Shade corrected object or NULL on error.
* \ingroup WlzValueFilters
* \brief Shade corrects the given 2D domain object with grey
* values. Grey value types known to be the same.
* \param srcObj Given object to be shade
* corrected.
* \param shdObj Given bright field object.
* \param nrmVal Normalization value.
* \param inPlace Modify the grey values of the
* given object if non-zero.
* \param dstErr Destination error pointer, may
* be null.
*/
static WlzObject *WlzShadeCorrect2DG(WlzObject *srcObj, WlzObject *shdObj,
double nrmVal, int inPlace,
WlzErrorNum *dstErr)
{
int tI0,
iCnt, red, green, blue;
double tD0;
WlzUInt tUI0, tUI1;
WlzObject *uObj = NULL,
*uSrcObj = NULL,
*uShdObj = NULL,
*rtnObj = NULL;
WlzGreyP srcPix,
shdPix,
rtnPix;
WlzValues newVal;
WlzIntervalWSpace srcIWSp,
shdIWSp,
rtnIWSp;
WlzGreyWSpace srcGWSp,
shdGWSp,
rtnGWSp;
WlzErrorNum errNum = WLZ_ERR_NONE;
/* Find intersection of the given and shade objects. */
uObj = WlzIntersect2(srcObj, shdObj, &errNum);
/* Make new objects with the values of the given and shade objects
* but the domain of their intersection. */
if(errNum == WLZ_ERR_NONE)
{
uSrcObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, uObj->domain, srcObj->values,
NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
uShdObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, uObj->domain, shdObj->values,
NULL, NULL, &errNum);
}
/* Make a new object, again using the union for the domain, but this time
* either sharing the given objects values or creating a new value table. */
if(errNum == WLZ_ERR_NONE)
{
if(inPlace)
{
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, uObj->domain, srcObj->values,
NULL, NULL, &errNum);
}
else
{
newVal.v = WlzNewValueTb(uObj, srcObj->values.core->type,
WlzGetBackground(srcObj, NULL), &errNum);
if(errNum == WLZ_ERR_NONE)
{
if((rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, uObj->domain, newVal,
NULL, NULL, &errNum)) == NULL)
{
(void )WlzFreeValueTb(newVal.v);
}
}
}
}
/* Work through the intervals setting the grey values. */
if(errNum == WLZ_ERR_NONE)
{
if(((errNum = WlzInitGreyScan(uSrcObj, &srcIWSp,
&srcGWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzInitGreyScan(uShdObj, &shdIWSp,
&shdGWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzInitGreyScan(rtnObj, &rtnIWSp,
&rtnGWSp)) == WLZ_ERR_NONE))
{
while(((errNum = WlzNextGreyInterval(&srcIWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&shdIWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&rtnIWSp)) == WLZ_ERR_NONE))
{
srcPix = srcGWSp.u_grintptr;
shdPix = shdGWSp.u_grintptr;
rtnPix = rtnGWSp.u_grintptr;
iCnt = rtnIWSp.rgtpos - rtnIWSp.lftpos + 1;
switch(rtnGWSp.pixeltype)
{
case WLZ_GREY_INT:
while(iCnt-- > 0)
{
tD0 = (*(srcPix.inp)++ * nrmVal) / (*(shdPix.inp)++ + 1.0);
*(rtnPix.inp)++ = WLZ_NINT(tD0);
}
break;
case WLZ_GREY_SHORT:
while(iCnt-- > 0)
{
tD0 = (*(srcPix.shp)++ * nrmVal) / (*(shdPix.shp)++ + 1.0);
tI0 = WLZ_NINT(tD0);
*(rtnPix.shp)++ = (short )WLZ_CLAMP(tI0, SHRT_MIN, SHRT_MAX);
}
break;
case WLZ_GREY_UBYTE:
while(iCnt-- > 0)
{
tD0 = (*(srcPix.ubp)++ * nrmVal) / (*(shdPix.ubp)++ + 1.0);
tI0 = WLZ_NINT(tD0);
*(rtnPix.ubp)++ = (WlzUByte )WLZ_CLAMP(tI0, 0, 255);
}
break;
case WLZ_GREY_FLOAT:
while(iCnt-- > 0)
{
tD0 = (*(srcPix.flp)++ * nrmVal) / (*(shdPix.flp)++ + 1.0);
*(rtnPix.flp)++ = (float )tD0;
}
break;
case WLZ_GREY_DOUBLE:
while(iCnt-- > 0)
{
tD0 = (*(srcPix.dbp)++ * nrmVal) / (*(shdPix.dbp)++ + 1.0);
*(rtnPix.dbp)++ = tD0;
}
break;
case WLZ_GREY_RGBA:
while(iCnt-- > 0)
{
/* slightly different logic here. Avoid divide by zero
by explicit check */
tUI0 = *(srcPix.rgbp)++;
tUI1 = *(shdPix.rgbp)++;
red = WLZ_RGBA_RED_GET(tUI1);
red = (red)?
(int )(((WLZ_RGBA_RED_GET(tUI0) * nrmVal))/red):
(int )nrmVal;
red = WLZ_CLAMP(red, 0, 255);
green = WLZ_RGBA_GREEN_GET(tUI1);
green = (green)?
(int )(((WLZ_RGBA_GREEN_GET(tUI0) * nrmVal))/green):
(int )nrmVal;
green = WLZ_CLAMP(green, 0, 255);
blue = WLZ_RGBA_BLUE_GET(tUI1);
blue = (blue)?
(int )(((WLZ_RGBA_BLUE_GET(tUI0) * nrmVal))/blue):
(int )nrmVal;
blue = WLZ_CLAMP(blue, 0, 255);
WLZ_RGBA_RGBA_SET(tUI0, red, green, blue, 255);
*(rtnPix.rgbp)++ = tUI0;
}
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
if(errNum == WLZ_ERR_EOO) /* Reset error from end of intervals */
{
errNum = WLZ_ERR_NONE;
}
}
}
(void )WlzFreeObj(uObj);
(void )WlzFreeObj(uSrcObj);
(void )WlzFreeObj(uShdObj);
if(errNum != WLZ_ERR_NONE)
{
(void )WlzFreeObj(rtnObj);
rtnObj = NULL;
}
if(dstErr)
{
*dstErr = errNum;
}
return(rtnObj);
}
/*!
* \return Distance object which shares the given foreground object's
* domain and has integer distance values, null on error.
* \ingroup WlzMorphologyOps
* \brief Computes the distance of every pixel/voxel in the foreground
* object from the reference object.
*
* A distance transform maps all position within a forground
* domain to their distances from a reference domain.
* The distance transforms implemented within this function
* use efficient morphological primitives.
*
* Given two domains,
* \f$\Omega_r\f$ the reference domain and \f$\Omega_f\f$
* the domain specifying the region of interest,
* a domain with a thin shell \f$\Omega_i\f$
* is iteratively expanded from it's initial domain
* corresponding to the reference domain \f$\Omega_r\f$.
* At each iteration
* \f$\Omega_i\f$ is dilated and clipped
* by it's intersection with \f$\Omega_f\f$ until \f$\Omega_i\f$
* becomes the null domain \f$\emptyset\f$.
* At each iteration the current distance is recorded in a value
* table which
* covers the domain \f$\Omega_f\f$.
*
* An octagonal distance scheme may be used in which
* the distance metric is alternated between 4 and 8
* connected for 2D and 6 and 26 connectivities in 3D.
* See: G. Borgefors. "Distance Transformations in Arbitrary
* Dimensions" CVGIP 27:321-345, 1984.
*
* An approximate Euclidean distance transform may be computed
* by: Scaling the given foreground and reference objects using
* the given approximation scale parameter, dilating the
* reference domain using a sphere with a radius having the same
* value as the scale parameter and then finaly sampling the
* scaled distances.
* \param forObj Foreground object.
* \param refObj Reference object.
* \param dFn Distance function which must be
* appropriate to the dimension of
* the foreground and reference objects.
* \param dParam Parameter required for distance
* function. Currently only
* WLZ_APX_EUCLIDEAN_DISTANCE requires a
* parameter. In this case the parameter
* is the approximation scale.
* \param dstErr Destination error pointer, may be NULL.
*/
WlzObject *WlzDistanceTransform(WlzObject *forObj, WlzObject *refObj,
WlzDistanceType dFn, double dParam,
WlzErrorNum *dstErr)
{
int idP,
lastP,
dim,
notDone = 1;
double scale;
WlzObject *tmpObj,
*sObj = NULL,
*sForObj = NULL,
*sRefObj = NULL,
*dilObj = NULL,
*dstObj = NULL,
*difObj = NULL,
*curItrObj = NULL;
WlzObject *bothObj[2];
WlzDomain *difDoms;
WlzPixelV dstV,
bgdV;
WlzValues *difVals;
WlzAffineTransform *tr = NULL;
WlzConnectType con;
WlzObjectType dstGType;
WlzErrorNum errNum = WLZ_ERR_NONE;
WlzValues difVal,
dstVal,
nullVal;
/* By defining WLZ_DIST_TRANSFORM_ENV these normalization parameters
* are read from the environment. This is useful for optimization. */
#ifndef WLZ_DIST_TRANSFORM_ENV
const
#endif /* ! WLZ_DIST_TRANSFORM_ENV */
/* These normalizarion factors have been choosen to minimize the sum of
* squares of the deviation of the distance values from Euclidean values
* over a radius 100 circle or sphere, where the distances are computed
* from the circumference of the sphere towards it's centre. The values
* were established by experiment. */
double nrmDist4 = 0.97,
nrmDist6 = 0.91,
nrmDist8 = 1.36,
nrmDist18 = 1.34,
nrmDist26 = 1.60;
#ifdef WLZ_DIST_TRANSFORM_ENV
double val;
char *envStr;
if(((envStr = getenv("WLZ_DIST_TRANSFORM_NRMDIST4")) != NULL) &&
(sscanf(envStr, "%lg", &val) == 1))
{
nrmDist4 = val;
}
if(((envStr = getenv("WLZ_DIST_TRANSFORM_NRMDIST6")) != NULL) &&
(sscanf(envStr, "%lg", &val) == 1))
{
nrmDist6 = val;
}
if(((envStr = getenv("WLZ_DIST_TRANSFORM_NRMDIST8")) != NULL) &&
(sscanf(envStr, "%lg", &val) == 1))
{
nrmDist8 = val;
}
if(((envStr = getenv("WLZ_DIST_TRANSFORM_NRMDIST18")) != NULL) &&
(sscanf(envStr, "%lg", &val) == 1))
{
nrmDist18 = val;
}
if(((envStr = getenv("WLZ_DIST_TRANSFORM_NRMDIST26")) != NULL) &&
(sscanf(envStr, "%lg", &val) == 1))
{
nrmDist26 = val;
}
#endif /* WLZ_DIST_TRANSFORM_ENV */
scale = dParam;
nullVal.core = NULL;
/* Check parameters. */
if((forObj == NULL) || (refObj == NULL))
{
errNum = WLZ_ERR_OBJECT_NULL;
}
else if(((forObj->type != WLZ_2D_DOMAINOBJ) &&
(forObj->type != WLZ_3D_DOMAINOBJ)) ||
((refObj->type != WLZ_POINTS) &&
(refObj->type != forObj->type)))
{
errNum = WLZ_ERR_OBJECT_TYPE;
}
else if((forObj->domain.core == NULL) || (refObj->domain.core == NULL))
{
errNum = WLZ_ERR_DOMAIN_NULL;
}
if(errNum == WLZ_ERR_NONE)
{
bgdV.type = WLZ_GREY_INT;
bgdV.v.inv = 0;
dstV.type = WLZ_GREY_DOUBLE;
dstV.v.dbv = 0.0;
switch(forObj->type)
{
case WLZ_2D_DOMAINOBJ:
switch(dFn)
{
case WLZ_4_DISTANCE: /* FALLTHROUGH */
case WLZ_8_DISTANCE: /* FALLTHROUGH */
case WLZ_OCTAGONAL_DISTANCE: /* FALLTHROUGH */
case WLZ_APX_EUCLIDEAN_DISTANCE:
dim = 2;
break;
default:
errNum = WLZ_ERR_PARAM_DATA;
break;
}
break;
case WLZ_3D_DOMAINOBJ:
switch(dFn)
{
case WLZ_6_DISTANCE: /* FALLTHROUGH */
case WLZ_18_DISTANCE: /* FALLTHROUGH */
case WLZ_26_DISTANCE: /* FALLTHROUGH */
case WLZ_OCTAGONAL_DISTANCE: /* FALLTHROUGH */
case WLZ_APX_EUCLIDEAN_DISTANCE:
dim = 3;
break;
default:
errNum = WLZ_ERR_PARAM_DATA;
break;
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
if(errNum == WLZ_ERR_NONE)
{
switch(dFn)
{
case WLZ_4_DISTANCE:
con = WLZ_4_CONNECTED;
break;
case WLZ_6_DISTANCE:
con = WLZ_6_CONNECTED;
break;
case WLZ_8_DISTANCE:
con = WLZ_8_CONNECTED;
break;
case WLZ_18_DISTANCE:
con = WLZ_18_CONNECTED;
break;
case WLZ_26_DISTANCE:
con = WLZ_26_CONNECTED;
break;
case WLZ_OCTAGONAL_DISTANCE:
con = (dim == 2)? WLZ_8_CONNECTED: WLZ_26_CONNECTED;
break;
case WLZ_APX_EUCLIDEAN_DISTANCE:
con = (dim == 2)? WLZ_8_CONNECTED: WLZ_26_CONNECTED;
if(scale < 1.0)
{
errNum = WLZ_ERR_PARAM_DATA;
}
break;
case WLZ_EUCLIDEAN_DISTANCE:
errNum = WLZ_ERR_UNIMPLEMENTED;
break;
default:
errNum = WLZ_ERR_PARAM_DATA;
break;
}
}
/* Create scaled domains and a sphere domain for structual erosion if the
* distance function is approximate Euclidean. */
if(errNum == WLZ_ERR_NONE)
{
if(dFn == WLZ_APX_EUCLIDEAN_DISTANCE)
{
tr = (dim == 2)?
WlzAffineTransformFromScale(WLZ_TRANSFORM_2D_AFFINE,
scale, scale, 0.0, &errNum):
WlzAffineTransformFromScale(WLZ_TRANSFORM_3D_AFFINE,
scale, scale, scale, &errNum);
if(errNum == WLZ_ERR_NONE)
{
tmpObj = WlzMakeMain(forObj->type, forObj->domain, nullVal,
NULL, NULL, &errNum);
if(tmpObj)
{
sForObj = WlzAssignObject(
WlzAffineTransformObj(tmpObj, tr,
WLZ_INTERPOLATION_NEAREST,
&errNum), NULL);
(void )WlzFreeObj(tmpObj);
}
}
if(errNum == WLZ_ERR_NONE)
{
if(refObj->type == WLZ_POINTS)
{
sRefObj = WlzPointsToDomObj(refObj->domain.pts, scale, &errNum);
}
else /* type == WLZ_2D_DOMAINOBJ || type == WLZ_3D_DOMAINOBJ */
{
tmpObj = WlzMakeMain(refObj->type, refObj->domain, nullVal,
NULL, NULL, &errNum);
if(errNum == WLZ_ERR_NONE)
{
sRefObj = WlzAssignObject(
WlzAffineTransformObj(tmpObj, tr,
WLZ_INTERPOLATION_NEAREST,
&errNum), NULL);
}
}
(void )WlzFreeObj(tmpObj);
}
if(errNum == WLZ_ERR_NONE)
{
sObj = WlzAssignObject(
WlzMakeSphereObject(forObj->type, scale,
0.0, 0.0, 0.0, &errNum), NULL);
}
(void )WlzFreeAffineTransform(tr);
}
else
{
sForObj = WlzAssignObject(
WlzMakeMain(forObj->type, forObj->domain, nullVal,
NULL, NULL, &errNum), NULL);
if(errNum == WLZ_ERR_NONE)
{
if(refObj->type == WLZ_POINTS)
{
sRefObj = WlzPointsToDomObj(refObj->domain.pts, 1.0, &errNum);
}
else
{
sRefObj = WlzAssignObject(
WlzMakeMain(refObj->type, refObj->domain, nullVal,
NULL, NULL, &errNum), NULL);
}
}
}
}
/* Create new values for the computed distances. */
if(errNum == WLZ_ERR_NONE)
{
dstGType = WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_INT, NULL);
if(dim == 2)
{
dstVal.v = WlzNewValueTb(sForObj, dstGType, bgdV, &errNum);
}
else
{
dstVal.vox = WlzNewValuesVox(sForObj, dstGType, bgdV, &errNum);
}
}
/* Create a distance object using the foreground object's domain and
* the new distance values. */
if(errNum == WLZ_ERR_NONE)
{
dstObj = WlzMakeMain(sForObj->type, sForObj->domain, dstVal,
NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
bothObj[0] = sForObj;
errNum = WlzGreySetValue(dstObj, dstV);
}
/* Dilate the reference object while setting the distances in each
* dilated shell. */
while((errNum == WLZ_ERR_NONE) && notDone)
{
if(dFn == WLZ_APX_EUCLIDEAN_DISTANCE)
{
dstV.v.dbv += 1.0;
}
else
{
switch(con)
{
case WLZ_4_CONNECTED:
dstV.v.dbv += nrmDist4;
break;
case WLZ_6_CONNECTED:
dstV.v.dbv += nrmDist6;
break;
case WLZ_8_CONNECTED:
dstV.v.dbv += nrmDist8;
break;
case WLZ_18_CONNECTED:
dstV.v.dbv += nrmDist18;
break;
case WLZ_26_CONNECTED:
dstV.v.dbv += nrmDist26;
break;
default:
errNum = WLZ_ERR_CONNECTIVITY_TYPE;
break;
}
}
if(dFn == WLZ_APX_EUCLIDEAN_DISTANCE)
{
dilObj = WlzStructDilation(sRefObj, sObj, &errNum);
}
else
{
dilObj = WlzDilation(sRefObj, con, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
switch(sForObj->type)
{
case WLZ_2D_DOMAINOBJ:
curItrObj = WlzAssignObject(
WlzIntersect2(dilObj, sForObj, &errNum), NULL);
break;
case WLZ_3D_DOMAINOBJ:
bothObj[1] = dilObj;
curItrObj = WlzAssignObject(
WlzIntersectN(2, bothObj, 1, &errNum), NULL);
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
(void)WlzFreeObj(dilObj);
/* Create difference object for the expanding shell. */
if(errNum == WLZ_ERR_NONE)
{
difObj = WlzDiffDomain(curItrObj, sRefObj, &errNum);
}
if((difObj == NULL) || WlzIsEmpty(difObj, &errNum))
{
notDone = 0;
}
else
{
/* Assign the distance object's values to the difference object
* and set all it's values to the current distance. */
if(errNum == WLZ_ERR_NONE)
{
switch(sForObj->type)
{
case WLZ_2D_DOMAINOBJ:
difObj->values = WlzAssignValues(dstObj->values, NULL);
errNum = WlzGreySetValue(difObj, dstV);
break;
case WLZ_3D_DOMAINOBJ:
/* 3D is more complex than 2D: Need to create a temporary
* voxel valuetable and assign the individual 2D values. */
difVal.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY,
difObj->domain.p->plane1,
difObj->domain.p->lastpl,
bgdV, NULL, &errNum);
if(errNum == WLZ_ERR_NONE)
{
difObj->values = WlzAssignValues(difVal, NULL);
difDoms = difObj->domain.p->domains;
difVals = difObj->values.vox->values;
idP = difObj->domain.p->plane1;
lastP = difObj->domain.p->lastpl;
while(idP <= lastP)
{
if((*difDoms).core)
{
dstVal = dstObj->values.vox->values[idP -
dstObj->domain.p->plane1];
*difVals = WlzAssignValues(dstVal, NULL);
}
++idP;
++difDoms;
++difVals;
}
if(difObj->domain.p->lastpl > difObj->domain.p->plane1)
{
errNum = WlzGreySetValue(difObj, dstV);
}
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
(void )WlzFreeObj(sRefObj);
sRefObj = WlzAssignObject(curItrObj, NULL);
(void )WlzFreeObj(curItrObj);
}
(void )WlzFreeObj(difObj); difObj = NULL;
if(dFn == WLZ_OCTAGONAL_DISTANCE)
{
/* Alternate connectivities for octagonal distance. */
if(dim == 2)
{
con = (con == WLZ_4_CONNECTED)? WLZ_8_CONNECTED: WLZ_4_CONNECTED;
}
else /* dim == 3 */
{
con = (con == WLZ_6_CONNECTED)? WLZ_26_CONNECTED: WLZ_6_CONNECTED;
}
}
}
(void )WlzFreeObj(sObj);
(void )WlzFreeObj(sForObj);
(void )WlzFreeObj(sRefObj);
(void )WlzFreeObj(curItrObj);
if((errNum == WLZ_ERR_NONE) && (dFn == WLZ_APX_EUCLIDEAN_DISTANCE))
{
tmpObj = WlzDistSample(dstObj, dim, scale, &errNum);
(void )WlzFreeObj(dstObj);
dstObj = tmpObj;
}
if(errNum != WLZ_ERR_NONE)
{
(void )WlzFreeObj(dstObj); dstObj = NULL;
}
if(dstErr)
{
*dstErr = errNum;
}
return(dstObj);
}
/*!
* \return Transformed object.
* \ingroup WlzTransform
* \brief Transform an object using the given view-transform.
* Typically this is for mapping section data back into
* the 3D space of the reference image/reconstruction.
* \param srcObj Given source object.
* \param viewStr Given view transform.
* \param dstErr Destination error pointer, may be NULL.
*/
WlzObject *Wlz3DViewTransformObj(
WlzObject *srcObj,
WlzThreeDViewStruct *viewStr,
WlzErrorNum *dstErr)
{
WlzErrorNum errNum=WLZ_ERR_NONE;
AlcErrno alcErr = ALC_ER_NONE;
WlzObject *dstObj=NULL;
int area;
int i, k, p, xp, yp, line;
int plane1, lastpl, line1, lastln, kol1, lastkl;
WlzIVertex3 *vertices;
int numVtxs, vtxIdx;
WlzIntervalWSpace iwsp;
WlzGreyWSpace gwsp;
WlzDomain domain, tmpDomain;
WlzValues values;
int numInts, itvlFlg;
WlzInterval *itvl;
/* check the object */
if( srcObj == NULL ) {
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( srcObj->type ) {
case WLZ_2D_DOMAINOBJ:
if( srcObj->domain.core == NULL ) {
errNum = WLZ_ERR_DOMAIN_NULL;
}
area = WlzArea(srcObj, &errNum);
if( area == 0 ) {
dstObj = WlzMakeEmpty(&errNum);
}
break;
case WLZ_2D_POLYGON: /* to be done at some time to 3D polyline */
case WLZ_BOUNDLIST: /* convert to 3D polylines */
case WLZ_TRANS_OBJ:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* create the voxel list */
if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) {
numVtxs = sizeof(WlzIVertex3) * (area+4);
vertices = AlcMalloc(sizeof(WlzIVertex3) * (area+4));
numVtxs = 0;
if( vertices ) {
errNum = WlzInitRasterScan(srcObj, &iwsp, WLZ_RASTERDIR_ILIC);
}
else {
errNum = WLZ_ERR_MEM_ALLOC;
}
if( errNum == WLZ_ERR_NONE ) {
while( (errNum = WlzNextInterval(&iwsp)) == WLZ_ERR_NONE ) {
float x, y, z;
if((iwsp.linpos < (int) viewStr->minvals.vtY) ||
(iwsp.linpos > (int) viewStr->maxvals.vtY)) {
continue;
}
yp = iwsp.linpos - (int) viewStr->minvals.vtY;
for(k=iwsp.lftpos; k <= iwsp.rgtpos; k++) {
if((k < (int) viewStr->minvals.vtX) ||
(k > (int) viewStr->maxvals.vtX)) {
continue;
}
xp = k - (int) viewStr->minvals.vtX;
x = (float )(viewStr->xp_to_x[xp] + viewStr->yp_to_x[yp]);
y = (float )(viewStr->xp_to_y[xp] + viewStr->yp_to_y[yp]);
z = (float )(viewStr->xp_to_z[xp] + viewStr->yp_to_z[yp]);
vertices[numVtxs].vtX = WLZ_NINT(x);
vertices[numVtxs].vtY = WLZ_NINT(y);
vertices[numVtxs].vtZ = WLZ_NINT(z);
numVtxs++;
}
}
if(errNum == WLZ_ERR_EOO) /* Reset error from end of object */
{
errNum = WLZ_ERR_NONE;
}
}
}
/* sort wrt planes, lines, kols */
if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) {
qsort((void *) vertices, (size_t) numVtxs, sizeof(WlzIVertex3),
compareVtxVal);
/* create planedomain */
plane1 = vertices[0].vtZ;
lastpl = vertices[numVtxs - 1].vtZ;
line1 = vertices[0].vtY;
lastln = line1;
kol1 = vertices[0].vtX;
lastkl = kol1;
for(i=1; i < numVtxs; i++) {
if( kol1 > vertices[i].vtX ) {
kol1 = vertices[i].vtX;
}
if( lastkl < vertices[i].vtX ) {
lastkl = vertices[i].vtX;
}
if( line1 > vertices[i].vtY ) {
line1 = vertices[i].vtY;
}
if( lastln < vertices[i].vtY ) {
lastln = vertices[i].vtY;
}
}
if( (domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
plane1, lastpl,
line1, lastln,
kol1, lastkl,
&errNum)) == NULL ) {
AlcFree((void *) vertices);
}
}
/* for each plane count intervals and make domain */
if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) {
vtxIdx = 0;
for(p=plane1; p <= lastpl; p++) {
/* increment vertex index to current plane */
while( vertices[vtxIdx].vtZ < p ) {
vtxIdx++;
}
/* check for empty domain */
if( vertices[vtxIdx].vtZ > p ) {
domain.p->domains[p - plane1].i = NULL;
continue;
}
/* estimate intervals - foreach pixel add one,
foreach adjacent pixel on the same line subtract one */
numInts = 1;
kol1 = vertices[vtxIdx].vtX;
lastkl = kol1;
for(i=vtxIdx+1; i < numVtxs; i++) {
if( vertices[i].vtZ > p ) {
break;
}
numInts++;
if((vertices[i].vtY == vertices[i-1].vtY) &&
((vertices[i].vtX == (vertices[i-1].vtX)) ||
(vertices[i].vtX == (vertices[i-1].vtX + 1))
)) {
numInts--;
}
if(kol1 > vertices[i].vtX) {
kol1 = vertices[i].vtX;
}
if(lastkl < vertices[i].vtX) {
lastkl = vertices[i].vtX;
}
}
line1 = vertices[vtxIdx].vtY;
lastln = vertices[i-1].vtY;
/* make the domain and add the intervals pointer */
tmpDomain.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL,
line1, lastln,
kol1, lastkl,
&errNum);
itvl = (WlzInterval *) AlcMalloc(sizeof(WlzInterval)*numInts);
tmpDomain.i->freeptr = AlcFreeStackPush(tmpDomain.i->freeptr,
(void *) itvl,
&alcErr);
if(alcErr != ALC_ER_NONE) {
errNum = WLZ_ERR_MEM_ALLOC;
}
/* one more loop to add the intervals */
itvl->ileft = vertices[vtxIdx].vtX - kol1;
line = vertices[vtxIdx].vtY;
itvlFlg = 1; /* interval started */
numInts = 1;
for(i=vtxIdx+1; i < numVtxs; i++) {
/* new plane -> interval finished if started */
if( vertices[i].vtZ > p ) {
if( itvlFlg ) {
itvl[numInts-1].iright = vertices[i-1].vtX - kol1;
WlzMakeInterval(line, tmpDomain.i, numInts, itvl);
itvl += numInts;
itvlFlg = 0; /* interval finished */
numInts = 0;
}
break;
}
/* check if new interval */
if( !itvlFlg ) {
itvl->ileft = vertices[i].vtX - kol1;
line = vertices[i].vtY;
itvlFlg = 1;
numInts = 1;
continue; /* no further tests */
}
/* check for gap - increment interval count */
if((vertices[i].vtY == line) &&
((vertices[i].vtX - vertices[i-1].vtX) > 1)) {
itvl[numInts-1].iright = vertices[i-1].vtX - kol1;
numInts++;
itvl[numInts-1].ileft = vertices[i].vtX - kol1;
itvlFlg = 1;
}
/* check for new-line */
if( line < vertices[i].vtY ) {
itvl[numInts-1].iright = vertices[i-1].vtX - kol1;
WlzMakeInterval(line, tmpDomain.i, numInts, itvl);
itvl += numInts;
itvl->ileft = vertices[i].vtX - kol1;
line = vertices[i].vtY;
itvlFlg = 1;
numInts = 1;
}
}
/* complete the last interval */
if( itvlFlg ) {
itvl[numInts-1].iright = vertices[i-1].vtX - kol1;
WlzMakeInterval(line, tmpDomain.i, numInts, itvl);
itvl += numInts;
}
/* add the domain to the planedomain */
domain.p->domains[p - plane1] =
WlzAssignDomain(tmpDomain, &errNum);
(void) WlzIntervalCount(tmpDomain.i, 0);
}
}
/* create the new object */
if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) {
values.core = NULL;
dstObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
/* check for grey-level data */
if((errNum == WLZ_ERR_NONE) && dstObj &&
(dstObj->type != WLZ_EMPTY_OBJ) && srcObj->values.core ) {
WlzPixelV bckgrnd;
WlzObject *tmpObj;
WlzValues tmpValues;
WlzDVertex3 vtx;
WlzGreyValueWSpace *gVWSp = NULL;
WlzObjectType valueTbType;
/* explicit intialisation to satisfy strict ANSI on SGI */
bckgrnd = WlzGetBackground(srcObj, &errNum);
valueTbType = WlzGreyTableType(WLZ_GREY_TAB_RAGR,
bckgrnd.type, NULL);
/* make a voxel table */
values.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY,
plane1, lastpl, bckgrnd,
NULL, &errNum);
dstObj->values = WlzAssignValues(values, &errNum);
/* set up grey-value random access to original
and loop through planes setting values */
gVWSp = WlzGreyValueMakeWSp(srcObj, NULL);
for(p=plane1; p <= lastpl; p++) {
/* check for empty domain */
if( domain.p->domains[p-plane1].core == NULL ) {
continue;
}
/* make a value table */
tmpObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain.p->domains[p-plane1],
values.vox->values[p-plane1], NULL, NULL, &errNum);
tmpValues.v = WlzNewValueTb(tmpObj, valueTbType, bckgrnd, &errNum);
values.vox->values[p-plane1] = WlzAssignValues(tmpValues, &errNum);
tmpObj->values = WlzAssignValues(tmpValues, &errNum);
/* transfer values */
errNum = WlzInitGreyScan(tmpObj, &iwsp, &gwsp);
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE)) {
for(i=0; i<iwsp.colrmn; i++) {
vtx.vtX = iwsp.colpos + i;
vtx.vtY = iwsp.linpos;
vtx.vtZ = p;
Wlz3DSectionTransformVtx(&vtx, viewStr);
WlzGreyValueGet(gVWSp, 0.0,
WLZ_NINT(vtx.vtY), WLZ_NINT(vtx.vtX));
switch( gwsp.pixeltype ) {
case WLZ_GREY_LONG:
*(gwsp.u_grintptr.lnp+i) = gVWSp->gVal[0].lnv;
break;
case WLZ_GREY_INT:
*(gwsp.u_grintptr.inp+i) = gVWSp->gVal[0].inv;
break;
case WLZ_GREY_SHORT:
*(gwsp.u_grintptr.shp+i) = gVWSp->gVal[0].shv;
break;
case WLZ_GREY_UBYTE:
*(gwsp.u_grintptr.ubp+i) = gVWSp->gVal[0].ubv;
break;
case WLZ_GREY_FLOAT:
*(gwsp.u_grintptr.flp+i) = gVWSp->gVal[0].flv;
break;
case WLZ_GREY_DOUBLE:
*(gwsp.u_grintptr.dbp+i) = gVWSp->gVal[0].dbv;
break;
case WLZ_GREY_RGBA:
*(gwsp.u_grintptr.rgbp+i) = gVWSp->gVal[0].rgbv;
break;
case WLZ_GREY_BIT: /* not sure what to do with these */
default:
break;
}
}
}
if(errNum == WLZ_ERR_EOO) /* Reset error from end of object */
{
errNum = WLZ_ERR_NONE;
}
WlzFreeObj(tmpObj);
}
WlzGreyValueFreeWSp(gVWSp);
}
/* clean temp allocation */
if( vertices ) {
AlcFree((void *) vertices);
}
if( dstErr ) {
*dstErr = errNum;
}
return dstObj;
}
/*!
* \return New 3D domain object with corresponding WLZ_GREY_RGBA values.
* \ingroup WlzValuesUtils
* \brief Creates a WLZ_GREY_RGBA valued object from the given compound
* array. This is a static function which will always be called
* with valid parameters so they aren't checked.
* \param cObj Compound array object.
* \param cSpc The colour space.
* \param dstErr Destination error pointer may be NULL.
*/
static WlzObject *WlzCompoundToRGBA2D(WlzCompoundArray *cObj,
WlzRGBAColorSpace cSpc, WlzErrorNum *dstErr)
{
int i,
j;
WlzObject *rtnObj=NULL;
WlzPixelV bckgrnd;
WlzObject *objs[4];
WlzObjectType vType;
WlzUInt b[4];
WlzErrorNum errNum=WLZ_ERR_NONE;
/* Make a copy of the object pointers because WlzUnionN() modifies the
* array if it contains empty objects. */
for(i = 0; i < 3; ++i)
{
objs[i] = cObj->o[i];
}
rtnObj = WlzUnionN(3, objs, 0, &errNum);
if(errNum == WLZ_ERR_NONE)
{
/* Add an RGBA valuetable, extract background for each channel */
vType = WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_RGBA, &errNum);
for(i=0; (errNum == WLZ_ERR_NONE) && (i < 3); i++)
{
bckgrnd = WlzGetBackground(cObj->o[i], &errNum);
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzValueConvertPixel(&bckgrnd, bckgrnd, WLZ_GREY_UBYTE);
b[i] = bckgrnd.v.ubv;
}
}
}
if(errNum == WLZ_ERR_NONE)
{
WlzValues values;
bckgrnd.type = WLZ_GREY_RGBA;
WLZ_RGBA_RGBA_SET(bckgrnd.v.rgbv, b[0], b[1], b[2], 255);
values.v = WlzNewValueTb(rtnObj, vType, bckgrnd, &errNum);
if(values.v != NULL)
{
rtnObj->values = WlzAssignValues(values, &errNum);
}
else
{
(void )WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
/* Transfer values */
if( errNum == WLZ_ERR_NONE)
{
WlzGreyValueWSpace *gValWSpc[4];
WlzIntervalWSpace iwsp;
WlzGreyWSpace gwsp;
WlzGreyV gval;
/* do it dumb fashion for now, rgb only */
gValWSpc[0] = gValWSpc[1] = gValWSpc[2] = gValWSpc[3] = NULL;
for(i=0; i < 3; i++)
{
if((cObj->o[i] != NULL) && (cObj->o[i]->type != WLZ_EMPTY_OBJ))
{
gValWSpc[i] = WlzGreyValueMakeWSp(cObj->o[i], &errNum);
if(errNum != WLZ_ERR_NONE)
{
break;
}
}
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzInitGreyScan(rtnObj, &iwsp, &gwsp);
}
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE))
{
WlzPixelV pix;
for(j = iwsp.lftpos; j <= iwsp.rgtpos; j++)
{
for(i = 0; i < 3; i++)
{
if(gValWSpc[i] == NULL)
{
pix.v.ubv = (i < 2)? 0: 255;
}
else
{
WlzGreyValueGet(gValWSpc[i], 0, iwsp.linpos, j);
pix.type = gValWSpc[i]->gType;
pix.v = gValWSpc[i]->gVal[0];
WlzValueConvertPixel(&pix, pix, WLZ_GREY_UBYTE);
}
b[i] = pix.v.ubv;
}
WLZ_RGBA_RGBA_SET(gval.rgbv, b[0], b[1], b[2], b[3]);
*gwsp.u_grintptr.rgbp = gval.rgbv;
gwsp.u_grintptr.rgbp++;
}
}
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
for(i=0; i < 3; i++)
{
WlzGreyValueFreeWSp(gValWSpc[i]);
}
}
if(dstErr != NULL)
{
*dstErr = errNum;
}
return(rtnObj);
}
/*!
* \return New Woolz object.
* \ingroup WlzAllocation
* \brief Creates a new 2D spatial domain object by adding a
* rectangular buffer of values to the given current
* object (which may be NULL or empty).
* \param cObj Given current object.
* \param og Origin of rectangular buffer.
* \param sz Buffer size.
* \param gType Grey type which must be consistent
* with the current object and the
* buffer of values.
* \param bufSz Number of values in the buffer.
* \param bufP Given buffer of values.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzBuildObj2(WlzObject *cObj,
WlzIVertex2 og, WlzIVertex2 sz,
WlzGreyType gType, int bufSz, WlzGreyP bufP,
WlzErrorNum *dstErr)
{
WlzDomain bDom;
WlzValues bVal,
nVal;
WlzObject *bObj = NULL,
*nObj = NULL;
WlzPixelV bgdV;
WlzErrorNum errNum = WLZ_ERR_NONE;
bDom.core = NULL;
bVal.core = NULL;
nVal.core = NULL;
bgdV.type = WLZ_GREY_INT;
bgdV.v.inv = 0;
if(cObj)
{
WlzGreyType cGType = WLZ_GREY_ERROR;;
switch(cObj->type)
{
case WLZ_EMPTY_OBJ:
cObj = NULL;
break;
case WLZ_2D_DOMAINOBJ:
if(cObj->domain.core == NULL)
{
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if(cObj->values.core == NULL)
{
errNum = WLZ_ERR_VALUES_NULL;
}
else
{
cGType = WlzGreyTypeFromObj(cObj, &errNum);
bgdV = WlzGetBackground(cObj, &errNum);
}
if((errNum == WLZ_ERR_NONE) && (cGType != gType))
{
errNum = WLZ_ERR_GREY_TYPE;
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* Create new object with domain and values of given rectangular buffer. */
if(errNum == WLZ_ERR_NONE)
{
bDom.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_RECT,
og.vtY, og.vtY + sz.vtY - 1,
og.vtX, og.vtX + sz.vtX - 1,
&errNum);
}
if(errNum == WLZ_ERR_NONE)
{
WlzObjectType gTT;
gTT = WlzGreyTableType(WLZ_GREY_TAB_RECT, gType, NULL);
bVal.r = WlzMakeRectValueTb(gTT, bDom.i->line1, bDom.i->lastln,
bDom.i->kol1, sz.vtX, bgdV, bufP.inp, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
bObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, bDom, bVal, NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
if(cObj == NULL)
{
/* Just copy the buffer object. */
nObj = WlzCopyObject(bObj, &errNum);
}
else
{
/* Compute union of current and buffer objects. */
nObj = (cObj)? WlzUnion2(cObj, bObj, &errNum):
WlzMakeMain(WLZ_2D_DOMAINOBJ, bDom, nVal,
NULL, NULL, &errNum);
/* Create new value table. */
if(errNum == WLZ_ERR_NONE)
{
WlzObjectType gTT;
gTT = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gType, NULL);
nVal.v = WlzNewValueTb(nObj, gTT, bgdV, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
nObj->values = WlzAssignValues(nVal, NULL);
}
if(errNum == WLZ_ERR_NONE)
{
WlzObject *tObj;
/* Copy existing values to new object. */
tObj = WlzGreyTransfer(nObj, cObj, &errNum);
(void )WlzFreeObj(nObj);
nObj = tObj;
/* Then copy buffer values to new object. */
if(errNum == WLZ_ERR_NONE)
{
tObj = WlzGreyTransfer(nObj, bObj, &errNum);
(void )WlzFreeObj(nObj);
nObj = tObj;
}
}
}
}
(void )WlzFreeObj(bObj);
if(dstErr)
{
*dstErr = errNum;
}
return(nObj);
}
WlzObject *WlzAddValuesTable(
WlzObject *obj,
WlzGreyType gtype,
WlzPixelV bckgrnd,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzObjectType type;
WlzValues values, *valuess;
WlzDomain *domains;
WlzObject *tmpObj;
int p;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check inputs */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gtype, NULL);
values.v = WlzNewValueTb(obj, type, bckgrnd, &errNum);
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, obj->domain, values,
NULL, NULL, &errNum);
break;
case WLZ_3D_DOMAINOBJ:
values.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY,
obj->domain.p->plane1,
obj->domain.p->lastpl,
bckgrnd, NULL, &errNum);
rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, obj->domain, values,
NULL, NULL, &errNum);
domains = rtnObj->domain.p->domains;
valuess = rtnObj->values.vox->values;
type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_INT, &errNum);
for(p=0;
p < (rtnObj->domain.p->lastpl - rtnObj->domain.p->plane1 + 1);
p++, domains++, valuess++){
if( (*domains).core ){
values.core = NULL;
tmpObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains, values,
NULL, NULL, NULL);
values.v = WlzNewValueTb(tmpObj, type, bckgrnd, &errNum);
*valuess = WlzAssignValues(values, NULL);
WlzFreeObj(tmpObj);
}
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
WlzObject *WlzRGBAToChannel(
WlzObject *obj,
WlzRGBAColorChannel chan,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzValues values;
WlzObjectType type;
WlzPixelV pixVal, oldBck, newBck;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check object and channel */
if( obj ){
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if ( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( WlzGreyTypeFromObj(obj, &errNum) != WLZ_GREY_RGBA ){
errNum = WLZ_ERR_VALUES_TYPE;
}
break;
case WLZ_3D_DOMAINOBJ:
if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if( obj->domain.p->type != WLZ_PLANEDOMAIN_DOMAIN ){
errNum = WLZ_ERR_DOMAIN_TYPE;
}
else if ( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( obj->values.vox->type != WLZ_VOXELVALUETABLE_GREY ){
errNum = WLZ_ERR_VALUES_TYPE;
}
else if( WlzGreyTypeFromObj(obj, &errNum) != WLZ_GREY_RGBA ){
errNum = WLZ_ERR_VALUES_TYPE;
}
return WlzRGBAToChannel3D(obj, chan, dstErr);
case WLZ_TRANS_OBJ:
/* not difficult, do it later */
errNum = WLZ_ERR_OBJECT_TYPE;
break;
case WLZ_COMPOUND_ARR_1:
case WLZ_COMPOUND_ARR_2:
/* bit recursive this ! */
errNum = WLZ_ERR_OBJECT_TYPE;
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
}
}
else {
errNum = WLZ_ERR_OBJECT_NULL;
}
if( errNum == WLZ_ERR_NONE ){
switch( chan ){
case WLZ_RGBA_CHANNEL_RED:
case WLZ_RGBA_CHANNEL_GREEN:
case WLZ_RGBA_CHANNEL_BLUE:
case WLZ_RGBA_CHANNEL_HUE:
case WLZ_RGBA_CHANNEL_SATURATION:
case WLZ_RGBA_CHANNEL_BRIGHTNESS:
case WLZ_RGBA_CHANNEL_CYAN:
case WLZ_RGBA_CHANNEL_MAGENTA:
case WLZ_RGBA_CHANNEL_YELLOW:
break;
default:
errNum = WLZ_ERR_PARAM_DATA;
break;
}
}
/* now extract data */
if( errNum == WLZ_ERR_NONE ){
type = WlzGreyTableType(
WlzGreyTableTypeToTableType(obj->values.core->type, &errNum),
WLZ_GREY_UBYTE, &errNum);
oldBck = WlzGetBackground(obj, &errNum);
newBck.type = WLZ_GREY_UBYTE;
newBck.v.ubv = (WlzUByte )WlzRGBAPixelValue(oldBck, chan, &errNum);
}
/* make values table and return object */
if( errNum == WLZ_ERR_NONE ){
values.v = WlzNewValueTb(obj, type, newBck, &errNum);
rtnObj = WlzMakeMain(obj->type, obj->domain, values,
NULL, NULL, &errNum);
}
/* iterate through objects setting values */
if( errNum == WLZ_ERR_NONE ){
WlzIntervalWSpace iwsp0, iwsp1;
WlzGreyWSpace gwsp0, gwsp1;
int j, k;
errNum = WlzInitGreyScan(obj, &iwsp0, &gwsp0);
errNum = WlzInitGreyScan(rtnObj, &iwsp1, &gwsp1);
pixVal.type = WLZ_GREY_RGBA;
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp0)) == WLZ_ERR_NONE)){
errNum = WlzNextGreyInterval(&iwsp1);
for(j=0, k=iwsp0.lftpos; k <= iwsp0.rgtpos; j++, k++,
gwsp0.u_grintptr.rgbp++){
pixVal.v.rgbv = (*(gwsp0.u_grintptr.rgbp));
*(gwsp1.u_grintptr.ubp++) = (WlzUByte )
WlzRGBAPixelValue(pixVal, chan, &errNum);
}
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \return New Woolz domain object with maximal domain and grey
* values which encode the gradient's direction or NULL
* on error.
* \ingroup WlzFeatures
* \brief Computes the maximal domain and gradient direction of
* given Woolz 2D domain object.
* \note All the objects domains are known to be the same.
* \param grdM Gradient magnitude.
* \param grdY Gradient (partial derivative)
* through lines.
* \param grdX Gradient (partial derivative)
* through columns.
* \param minThrV Minimum gradient value to
* consider.
* \param dstErr Destination error pointer, may
* be null.
*/
static WlzObject *WlzNMSuppress2D(WlzObject *grdM,
WlzObject *grdY, WlzObject *grdX,
WlzPixelV minThrV, WlzErrorNum *dstErr)
{
int idN,
inLen,
outLen,
inLnIdx = 0;
WlzGreyType gType,
bufType;
WlzIVertex2 bufSz,
inPos,
outPos,
orgPos;
WlzValues tmpVal;
WlzDomain dstDom,
grdDom;
WlzIntervalWSpace tmpIWSp = {0},
grdMIWSp = {0},
grdYIWSp = {0},
grdXIWSp = {0};
WlzGreyWSpace tmpGWSp,
grdMGWSp,
grdYGWSp,
grdXGWSp;
WlzPixelV zeroV;
WlzGreyP grdMBufGP,
grdYBufGP,
grdXBufGP;
WlzDynItvPool pool;
WlzObject *dstObj = NULL,
*tmpObj = NULL;
void *grdYBuf = NULL,
*grdXBuf = NULL;
void **grdMBuf = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
tmpVal.core = NULL;
pool.itvBlock = NULL;
dstDom.core = NULL;
if((grdM->type != WLZ_2D_DOMAINOBJ) ||
(grdY->type != WLZ_2D_DOMAINOBJ) ||
(grdX->type != WLZ_2D_DOMAINOBJ))
{
errNum = WLZ_ERR_OBJECT_NULL;
}
else if((grdM->domain.core == NULL) ||
(grdY->domain.core == NULL) ||
(grdX->domain.core == NULL))
{
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if((grdM->values.core == NULL) ||
(grdY->values.core == NULL) ||
(grdX->values.core == NULL))
{
errNum = WLZ_ERR_VALUES_NULL;
}
else
{
/* Find required buffer type (WLZ_GREY_DOUBLE or WLZ_GREY_INT). */
bufType = WLZ_GREY_INT;
gType = WlzGreyTableTypeToGreyType(grdM->values.core->type, &errNum);
if(errNum == WLZ_ERR_NONE)
{
if((gType == WLZ_GREY_FLOAT) || (gType == WLZ_GREY_DOUBLE))
{
bufType = WLZ_GREY_DOUBLE;
}
else
{
gType = WlzGreyTableTypeToGreyType(grdY->values.core->type, &errNum);
if(errNum == WLZ_ERR_NONE)
{
if((gType == WLZ_GREY_FLOAT) || (gType == WLZ_GREY_DOUBLE))
{
bufType = WLZ_GREY_DOUBLE;
}
else
{
gType = WlzGreyTableTypeToGreyType(grdX->values.core->type,
&errNum);
if(errNum == WLZ_ERR_NONE)
{
if((gType == WLZ_GREY_FLOAT) || (gType == WLZ_GREY_DOUBLE))
{
bufType = WLZ_GREY_DOUBLE;
}
}
}
}
}
}
}
/* Convert minimum gradient threshold value. */
if(errNum == WLZ_ERR_NONE)
{
if(bufType == WLZ_GREY_INT)
{
errNum = WlzValueConvertPixel(&minThrV, minThrV, WLZ_GREY_INT);
}
else /* bufType == WLZ_GREY_DOUBLE */
{
errNum = WlzValueConvertPixel(&minThrV, minThrV, WLZ_GREY_DOUBLE);
}
}
if(errNum == WLZ_ERR_NONE)
{
grdDom = grdM->domain;
/* Make destination object with WLZ_GREY_UBYTE greys. */
zeroV.type = WLZ_GREY_UBYTE;
zeroV.v.inv = 0;
tmpVal.v = WlzNewValueTb(grdM, WlzGreyTableType(WLZ_GREY_TAB_RAGR,
WLZ_GREY_UBYTE, NULL),
zeroV, &errNum);
if(errNum == WLZ_ERR_NONE)
{
/* Use the input domain while calculating the new maximal domain. */
tmpObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, grdM->domain, tmpVal,
NULL, NULL, &errNum);
}
}
/* Initialize the memory pool with some size of block. Any +ve number
* greater than the maximum number of intervals in any destination line
* would work but the fewer allocations then the more efficient the code,
* hence this attempt to guess the required number of intervals in the
* destination domain. */
if(errNum == WLZ_ERR_NONE)
{
pool.itvsInBlock = (((grdDom.i->lastkl - grdDom.i->kol1 + 1) *
(grdDom.i->lastln - grdDom.i->line1 + 1)) / 64) +
grdDom.i->lastkl - grdDom.i->kol1 + 1024;
}
/* Make gradient buffers. */
if(errNum == WLZ_ERR_NONE)
{
bufSz.vtY = 3;
bufSz.vtX = grdDom.i->lastkl - grdDom.i->kol1 + 1;
if(bufType == WLZ_GREY_INT)
{
if((AlcInt2Malloc((int ***)&grdMBuf,
bufSz.vtY, bufSz.vtX) != ALC_ER_NONE) ||
((grdYBuf = AlcMalloc(sizeof(int) * bufSz.vtX)) == NULL) ||
((grdXBuf = AlcMalloc(sizeof(int) * bufSz.vtX)) == NULL))
{
errNum = WLZ_ERR_MEM_ALLOC;
}
else
{
grdYBufGP.inp = (int *)grdYBuf;
grdXBufGP.inp = (int *)grdXBuf;
}
}
else /* bufType == WLZ_GREY_DOUBLE */
{
if((AlcDouble2Malloc((double ***)&grdMBuf,
bufSz.vtY, bufSz.vtX) != ALC_ER_NONE) ||
((grdYBuf = AlcMalloc(sizeof(double) * bufSz.vtX)) == NULL) ||
((grdXBuf = AlcMalloc(sizeof(double) * bufSz.vtX)) == NULL))
{
errNum = WLZ_ERR_MEM_ALLOC;
}
else
{
grdYBufGP.dbp = (double *)grdYBuf;
grdXBufGP.dbp = (double *)grdXBuf;
}
}
}
/* Make destination interval domain with interval lines but not intervals. */
if(errNum == WLZ_ERR_NONE)
{
dstDom.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL,
grdDom.i->line1, grdDom.i->lastln,
grdDom.i->kol1, grdDom.i->lastkl,
&errNum);
}
if(errNum == WLZ_ERR_NONE)
{
/* Scan down through the gradient objects. */
if(((errNum = WlzInitGreyScan(tmpObj,
&tmpIWSp, &tmpGWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzInitGreyScan(grdM,
&grdMIWSp, &grdMGWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzInitGreyScan(grdY,
&grdYIWSp, &grdYGWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzInitGreyScan(grdX,
&grdXIWSp, &grdXGWSp)) == WLZ_ERR_NONE))
{
orgPos.vtX = grdDom.i->kol1;
orgPos.vtY = grdDom.i->line1;
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&grdMIWSp)) == WLZ_ERR_NONE))
{
inLen = grdMIWSp.rgtpos - grdMIWSp.lftpos + 1;
inPos.vtX = grdMIWSp.lftpos - orgPos.vtX;
/* Process any lines between this and the last by clearing the
* gradient magnitude buffer . */
if(grdMIWSp.nwlpos > 0)
{
idN = (grdMIWSp.nwlpos >= 3)? 3: grdMIWSp.nwlpos;
while(--idN >= 0)
{
inPos.vtY = grdMIWSp.linpos - orgPos.vtY - idN;
inLnIdx = (3 + inPos.vtY) % 3;
if(bufType == WLZ_GREY_INT)
{
WlzValueSetInt(*((int **)grdMBuf + inLnIdx), 0,
bufSz.vtX);
}
else /* bufType == WLZ_GREY_DOUBLE */
{
WlzValueSetDouble(*((double **)grdMBuf + inLnIdx), 0,
bufSz.vtX);
}
}
}
/* Copy intervals to values buffers. */
if(bufType == WLZ_GREY_INT)
{
grdMBufGP.inp = *((int **)grdMBuf + inLnIdx);
}
else /* bufType == WLZ_GREY_DOUBLE */
{
grdMBufGP.dbp = *((double **)grdMBuf + inLnIdx);
}
WlzValueCopyGreyToGrey(grdMBufGP, inPos.vtX, bufType,
grdMGWSp.u_grintptr, 0, grdMGWSp.pixeltype,
inLen);
if(grdMIWSp.intrmn == 0)
{
while((errNum == WLZ_ERR_NONE) &&
(tmpIWSp.linpos < grdMIWSp.linpos))
{
outPos.vtY = tmpIWSp.linpos - orgPos.vtY;
if(outPos.vtY >= 0)
{
outLen = tmpIWSp.rgtpos - tmpIWSp.lftpos + 1;
outPos.vtX = tmpIWSp.lftpos - orgPos.vtX;
WlzValueCopyGreyToGrey(grdYBufGP, 0, bufType,
grdYGWSp.u_grintptr, 0,
grdYGWSp.pixeltype, outLen);
WlzValueCopyGreyToGrey(grdXBufGP, 0, bufType,
grdXGWSp.u_grintptr, 0,
grdXGWSp.pixeltype, outLen);
if(bufType == WLZ_GREY_INT)
{
errNum = WlzNMSuppress2DBufI(dstDom.i,
(int **)grdMBuf,
(int *)grdYBuf,
(int *)grdXBuf,
&pool,
tmpGWSp.u_grintptr.ubp,
outLen, outPos, orgPos,
minThrV.v.inv);
}
else /* bufType == WLZ_GREY_DOUBLE */
{
errNum = WlzNMSuppress2DBufD(dstDom.i,
(double **)grdMBuf,
(double *)grdYBuf,
(double *)grdXBuf,
&pool,
tmpGWSp.u_grintptr.ubp,
outLen, outPos, orgPos,
minThrV.v.dbv);
}
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzNextGreyInterval(&tmpIWSp);
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzNextGreyInterval(&grdYIWSp);
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzNextGreyInterval(&grdXIWSp);
}
}
}
}
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
}
if(tmpIWSp.gryptr == &tmpGWSp)
{
(void )WlzEndGreyScan(&tmpIWSp, &tmpGWSp);
}
if(grdMIWSp.gryptr == &grdMGWSp)
{
(void )WlzEndGreyScan(&grdMIWSp, &grdMGWSp);
}
if(grdYIWSp.gryptr == &grdYGWSp)
{
(void )WlzEndGreyScan(&grdYIWSp, &grdYGWSp);
}
if(grdXIWSp.gryptr == &grdXGWSp)
{
(void )WlzEndGreyScan(&grdXIWSp, &grdXGWSp);
}
}
if(errNum == WLZ_ERR_NONE)
{
if((errNum = WlzStandardIntervalDomain(dstDom.i)) == WLZ_ERR_NONE)
{
dstObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, dstDom, tmpVal,
NULL, NULL, &errNum);
}
}
if(tmpObj)
{
WlzFreeObj(tmpObj);
}
if(errNum != WLZ_ERR_NONE)
{
if(tmpObj == NULL)
{
if(dstDom.core)
{
(void )WlzFreeDomain(dstDom);
}
if(tmpVal.core)
{
(void )WlzFreeValues(tmpVal);
}
}
}
if(grdMBuf)
{
Alc2Free(grdMBuf);
}
if(grdYBuf)
{
AlcFree(grdYBuf);
}
if(grdXBuf)
{
AlcFree(grdXBuf);
}
if(dstErr)
{
*dstErr = errNum;
}
return(dstObj);
}
/*!
* \ingroup WlzBinaryOps
* \brief Calculate the intersection of a set of objects. If
uvt=0 calculate domain only, uvt=1 calculate the mmean grey-value at
each point. Input objects must be all non-NULL and domain objects of
the same type i.e. either 2D or 3D otherwise an error is returned.
*
* \return Intersection object with grey-table as required, if the intersection is empty returns WLZ_EMPTY_OBJ, NULL on error.
* \param n number of input objects
* \param objs input object array
* \param uvt grey-table copy flag (1 - copy, 0 - no copy)
* \param dstErr error return.
* \par Source:
* WlzIntersectN.c
*/
WlzObject *WlzIntersectN(
int n,
WlzObject **objs,
int uvt,
WlzErrorNum *dstErr)
{
WlzObject *obj = NULL;
WlzIntervalDomain *idom;
WlzInterval *itvl, *jtvl;
WlzIntervalWSpace *iwsp;
WlzIntervalWSpace *biwsp,*tiwsp,niwsp;
WlzGreyWSpace *gwsp,ngwsp;
WlzDomain domain;
WlzValues values;
WlzObjectType type;
WlzPixelV backg;
WlzGreyP greyptr;
WlzGreyV gv;
int i, j, k, l, inttot, change, lwas, nints;
int line1, lastln;
int kol1, lastkl;
WlzErrorNum errNum = WLZ_ERR_NONE;
/*
* check pointers
*/
/* intersecction of no objects is an empty domain */
domain.i = NULL;
values.v = NULL;
if( n < 1 )
{
return WlzMakeEmpty(dstErr);
}
/* array pointer == NULL or any object pointer == NULL is an error */
if(objs == NULL){
errNum = WLZ_ERR_OBJECT_NULL;
}
else
{
for(i=0; i<n; i++){
if(objs[i] == NULL){
errNum = WLZ_ERR_OBJECT_NULL;
}
}
}
if(errNum != WLZ_ERR_NONE)
{
obj = NULL;
if(dstErr) {
*dstErr = errNum;
}
return(obj);
}
/* check type of first object */
switch( objs[0]->type ){
case WLZ_2D_DOMAINOBJ:
break;
case WLZ_3D_DOMAINOBJ:
return WlzIntersect3d(objs, n, uvt, &errNum);
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
/* check number */
if (n == 1){
obj = WlzMakeMain(objs[0]->type, objs[0]->domain, objs[0]->values,
NULL, NULL, &errNum);
if(dstErr) {
*dstErr = errNum;
}
return(obj);
}
/* check all objects are non-empty and have the same type
Note an empty object is not an error */
for (i=0; i<n; i++){
if( objs[i]->type != objs[0]->type ){
if( objs[i]->type == WLZ_EMPTY_OBJ ){
return WlzMakeEmpty(dstErr);
}
else {
errNum = WLZ_ERR_OBJECT_TYPE;
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
}
/* check for size */
if( WlzIsEmpty(objs[i], &errNum) ){
return WlzMakeEmpty(dstErr);
}
else {
if( errNum != WLZ_ERR_NONE ){
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
}
}
/*
* Find the line and column bounds of the intersection.
*/
line1 = objs[0]->domain.i->line1;
lastln = objs[0]->domain.i->lastln;
kol1 = objs[0]->domain.i->kol1;
lastkl = objs[0]->domain.i->lastkl;
for (i=1; i<n; i++) {
idom = objs[i]->domain.i;
if (line1 < idom->line1)
{
line1 = idom->line1;
}
if (lastln > idom->lastln)
{
lastln = idom->lastln;
}
if (kol1 < idom->kol1)
{
kol1 = idom->kol1;
}
if (lastkl > idom->lastkl)
{
lastkl = idom->lastkl;
}
}
if( lastkl < kol1 || lastln < line1 ){
return WlzMakeEmpty(dstErr);
}
/*
* Count the individual intervals so that sufficient space
* for the intersection may be allocated.
*/
inttot=0;
for (i=0; (i < n) && (errNum == WLZ_ERR_NONE); i++) {
inttot += WlzIntervalCount(objs[i]->domain.i, &errNum);
}
if(errNum != WLZ_ERR_NONE) {
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
/*
* Set up domain, value table structures, and object.
*/
if( (idom = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL,
line1, lastln, 0, lastkl-kol1,
&errNum)) == NULL ){
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
if( (itvl = (WlzInterval *)
AlcMalloc (inttot * sizeof(WlzInterval))) == NULL ){
WlzFreeIntervalDomain(idom);
errNum = WLZ_ERR_MEM_ALLOC;
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
idom->freeptr = AlcFreeStackPush(idom->freeptr, (void *)itvl, NULL);
lwas = line1;
jtvl = itvl;
nints = 0;
domain.i = idom;
values.v = NULL;
if( (obj = WlzMakeMain(WLZ_2D_DOMAINOBJ,
domain, values, NULL, NULL, &errNum)) == NULL ){
WlzFreeIntervalDomain(idom);
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
/*
* allocate space for workspaces
*/
if( (iwsp = (WlzIntervalWSpace *)
AlcMalloc(n * sizeof(WlzIntervalWSpace))) == NULL ){
WlzFreeObj( obj );
errNum = WLZ_ERR_MEM_ALLOC;
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
biwsp = iwsp;
tiwsp = biwsp + n;
/*
* Construct the intersection object's table of intervals.
* Initialise scanning on each object/workspace combination.
* Scan synchronously, setting up the intersection of
* overlapping intervals. Needs a clear head !!
*/
for (i=0; (i < n) && (errNum == WLZ_ERR_NONE); i++) {
errNum = WlzInitRasterScan(objs[i],iwsp,WLZ_RASTERDIR_ILIC);
if(errNum == WLZ_ERR_NONE) {
errNum = WlzNextInterval(iwsp++);
}
}
if(errNum != WLZ_ERR_NONE) {
WlzFreeObj( obj );
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
l = lwas;
for (;;) {
/*
* find next line of intersection
*/
do {
change = 0;
for (iwsp=biwsp; iwsp<tiwsp; iwsp++) {
if (iwsp->linpos > l) {
l = iwsp->linpos;
}
}
for (iwsp=biwsp; iwsp<tiwsp; iwsp++) {
while (iwsp->linpos < l) {
if ((errNum = WlzNextInterval(iwsp)) != WLZ_ERR_NONE) {
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
goto firstfinished;
}
if (iwsp->linpos > l) {
change = 1;
}
}
}
} while (change != 0);
/*
* find next interval of intersection
*/
kol1 = biwsp->lftpos;
lastkl = biwsp->rgtpos;
while(errNum == WLZ_ERR_NONE) {
do {
change = 0;
for (iwsp=biwsp; iwsp<tiwsp; iwsp++)
if (iwsp->lftpos > lastkl) {
kol1 = iwsp->lftpos;
lastkl = iwsp->rgtpos;
} else if (iwsp->lftpos > kol1)
kol1 = iwsp->lftpos;
for (iwsp=biwsp; iwsp<tiwsp; iwsp++) {
while (iwsp->rgtpos < kol1) {
if ((errNum = WlzNextInterval(iwsp)) != WLZ_ERR_NONE) {
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
goto firstfinished;
}
if (iwsp->linpos != l) {
l = iwsp->linpos;
goto jumpline;
}
if (iwsp->lftpos > kol1)
change = 1;
}
}
} while ((change != 0) && (errNum == WLZ_ERR_NONE));
if(errNum == WLZ_ERR_NONE)
{
for (iwsp=biwsp; iwsp < tiwsp; iwsp++) {
if (iwsp->rgtpos <= lastkl) {
lastkl = iwsp->rgtpos;
}
}
if (lastkl >= kol1) {
itvl->ileft = kol1 - idom->kol1;
itvl->iright = lastkl - idom->kol1;
if (l == lwas) {
nints++;
} else {
errNum = WlzMakeInterval(lwas,idom,nints,jtvl);
for (j = lwas+1; (j < l) && (errNum == WLZ_ERR_NONE); j++) {
errNum = WlzMakeInterval(j,idom,0,NULL);
}
if(errNum == WLZ_ERR_NONE) {
lwas = l;
nints = 1;
jtvl = itvl;
}
}
itvl++;
}
kol1 = lastkl+1;
}
}
jumpline:
;
}
firstfinished:
if(errNum != WLZ_ERR_NONE) {
WlzFreeObj(obj);
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
errNum = WlzMakeInterval(lwas,idom,nints,jtvl);
for (j = lwas+1; (j <= lastln) && (errNum == WLZ_ERR_NONE); j++) {
errNum = WlzMakeInterval(j,idom,0,NULL);
}
if(errNum != WLZ_ERR_NONE)
{
WlzFreeObj(obj);
AlcFree((void *) biwsp);
if(dstErr)
{
*dstErr = errNum;
}
return NULL;
}
/*
* standardise the interval list (remove leading and trailing
* empty lines, set kol1 so that at least one interval commences
* at zero, set lastkl correctly)
*/
(void )WlzStandardIntervalDomain(idom);
/* check for error or empty */
nints = WlzIntervalCount(idom, &errNum);
if( nints < 0 ){
/* error */
WlzFreeObj(obj);
AlcFree((void *) biwsp);
if(dstErr)
{
*dstErr = errNum;
}
return NULL;
}
else if( nints == 0 ){
/* empty object */
WlzFreeObj(obj);
AlcFree((void *) biwsp);
return WlzMakeEmpty(dstErr);
}
if (uvt != 0) {
WlzGreyType grey_type;
if( (gwsp = (WlzGreyWSpace *)
AlcMalloc (n * sizeof (WlzGreyWSpace))) == NULL ){
WlzFreeObj(obj);
AlcFree((void *) biwsp);
errNum = WLZ_ERR_MEM_ALLOC;
if(dstErr)
{
*dstErr = errNum;
}
return NULL;
}
/* construct an empty "ragged-rectangle" (type 1 or 2) greytable
choosing the grey-value type from the first object in the list */
backg = WlzGetBackground(objs[0], &errNum);
if(errNum == WLZ_ERR_NONE) {
grey_type = WlzGreyTableTypeToGreyType(objs[0]->values.core->type,
&errNum);
}
if(errNum == WLZ_ERR_NONE) {
type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, grey_type, &errNum);
}
if((errNum != WLZ_ERR_NONE) ||
(values.v = WlzNewValueTb(obj, type, backg, &errNum)) == NULL ){
WlzFreeObj( obj );
AlcFree((void *) gwsp);
AlcFree((void *) biwsp);
if(dstErr)
{
*dstErr = errNum;
}
return NULL;
}
obj->values = WlzAssignValues(values, &errNum);
if(errNum != WLZ_ERR_NONE) {
WlzFreeObj( obj );
AlcFree((void *) gwsp);
AlcFree((void *) biwsp);
if(dstErr)
{
*dstErr = errNum;
}
return NULL;
}
/*
* fill the grey table with mean of grey values.
*/
/* initialise the work-spaces and check pixel type */
errNum = WlzInitGreyScan(obj, &niwsp, &ngwsp);
iwsp = biwsp;
for (i=0; (i < n) && (errNum == WLZ_ERR_NONE); i++) {
errNum = WlzInitGreyScan(objs[i], iwsp, &gwsp[i]);
if(errNum == WLZ_ERR_NONE) {
errNum = WlzNextGreyInterval(iwsp++);
}
if( gwsp[i].pixeltype != grey_type ){
errNum = WLZ_ERR_GREY_TYPE;
}
}
if(errNum != WLZ_ERR_NONE) {
WlzFreeObj( obj );
AlcFree((void *) gwsp);
AlcFree((void *) biwsp);
if(dstErr) {
*dstErr = errNum;
}
return NULL;
}
while (WlzNextGreyInterval(&niwsp) == WLZ_ERR_NONE) {
l = niwsp.linpos;
greyptr = ngwsp.u_grintptr;
switch( ngwsp.pixeltype ){
case WLZ_GREY_INT:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
gv.inv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while(iwsp->linrmn >= 0 &&
(iwsp->linpos < l ||
(iwsp->linpos == l && iwsp->rgtpos < k))){
(void )WlzNextGreyInterval(iwsp);
}
gv.inv += *(gwsp[i].u_grintptr.inp + k - iwsp->lftpos);
}
*greyptr.inp = gv.inv / n;
greyptr.inp++;
}
break;
case WLZ_GREY_SHORT:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
gv.shv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while(iwsp->linrmn >= 0 &&
(iwsp->linpos < l ||
(iwsp->linpos == l && iwsp->rgtpos < k))){
(void )WlzNextGreyInterval(iwsp);
}
gv.shv += *(gwsp[i].u_grintptr.shp + k - iwsp->lftpos);
}
*greyptr.shp = (short )(gv.shv / n);
greyptr.shp++;
}
break;
case WLZ_GREY_UBYTE:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
gv.ubv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while(iwsp->linrmn >= 0 &&
(iwsp->linpos < l ||
(iwsp->linpos == l && iwsp->rgtpos < k))){
(void )WlzNextGreyInterval(iwsp);
}
gv.ubv += *(gwsp[i].u_grintptr.ubp + k - iwsp->lftpos);
}
*greyptr.ubp = (WlzUByte )(gv.ubv / n);
greyptr.ubp++;
}
break;
case WLZ_GREY_FLOAT:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
gv.flv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while(iwsp->linrmn >= 0 &&
(iwsp->linpos < l ||
(iwsp->linpos == l && iwsp->rgtpos < k))){
(void )WlzNextGreyInterval(iwsp);
}
gv.flv += *(gwsp[i].u_grintptr.flp + k - iwsp->lftpos);
}
*greyptr.flp = gv.flv / n;
greyptr.flp++;
}
break;
case WLZ_GREY_DOUBLE:
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
gv.dbv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while(iwsp->linrmn >= 0 &&
(iwsp->linpos < l ||
(iwsp->linpos == l && iwsp->rgtpos < k))){
(void )WlzNextGreyInterval(iwsp);
}
gv.dbv += *(gwsp[i].u_grintptr.dbp + k - iwsp->lftpos);
}
*greyptr.dbp = gv.dbv / n;
greyptr.dbp++;
}
break;
case WLZ_GREY_RGBA: /* RGBA to be done again RAB */
for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) {
gv.rgbv = 0;
for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) {
while(iwsp->linrmn >= 0 &&
(iwsp->linpos < l ||
(iwsp->linpos == l && iwsp->rgtpos < k))){
(void )WlzNextGreyInterval(iwsp);
}
gv.rgbv += *(gwsp[i].u_grintptr.rgbp + k - iwsp->lftpos);
}
*greyptr.rgbp = gv.rgbv / n;
greyptr.rgbp++;
}
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
AlcFree((void *) gwsp);
}
AlcFree((void *) biwsp);
if(dstErr) {
*dstErr = errNum;
}
return obj;
}
/*!
* \return projection object
* \ingroup WlzTransform
* \brief Use the view transform to define a projection from
* 3D to 2D. Currently only the domain is projected as
* an opaque shadow.
* This is old code temporarily kept for compatibility.
* \param obj source 3D object
* \param viewStr view structure defining the projection
* \param intFunc grey-value summation function
* \param intFuncData data to be passed to the integration function
* \param dstErr error return
*/
WlzObject *WlzGetProjectionFromObject(
WlzObject *obj,
WlzThreeDViewStruct *viewStr,
Wlz3DProjectionIntFn intFunc,
void *intFuncData,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL,
*obj1;
WlzThreeDViewStruct *viewStr1=NULL;
WlzDomain domain;
WlzValues values;
WlzGreyType srcGType = WLZ_GREY_UBYTE,
dstGType = WLZ_GREY_UBYTE;
WlzPixelV pixval;
WlzPixelP pixptr;
WlzIntervalWSpace iwsp;
WlzGreyWSpace gwsp;
WlzGreyValueWSpace *gVWSp = NULL;
WlzDVertex3 vtx, vtx1;
double x, y, z;
double *s_to_x=NULL;
double *s_to_y=NULL;
double *s_to_z=NULL;
int k, xp, yp, s, sp;
int length = 0, size = 0, occupiedFlg;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check inputs */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else if( obj->type != WLZ_3D_DOMAINOBJ ){
errNum = WLZ_ERR_OBJECT_TYPE;
}
else if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if( obj->domain.core->type != WLZ_PLANEDOMAIN_DOMAIN ){
errNum = WLZ_ERR_DOMAIN_TYPE;
}
if( (errNum == WLZ_ERR_NONE) && (viewStr == NULL) ){
errNum = WLZ_ERR_OBJECT_NULL;
}
/* create new view transform */
if( errNum == WLZ_ERR_NONE ){
if((viewStr1 = WlzMake3DViewStruct(WLZ_3D_VIEW_STRUCT, &errNum)) != NULL){
/* need to worry about fixed line mode here sometime */
viewStr1->fixed = viewStr->fixed;
viewStr1->theta = viewStr->theta;
viewStr1->phi = viewStr->phi;
viewStr1->zeta = viewStr->zeta;
viewStr1->dist = viewStr->dist;
viewStr1->scale = viewStr->scale;
viewStr1->voxelSize[0] = viewStr->voxelSize[0];
viewStr1->voxelSize[1] = viewStr->voxelSize[1];
viewStr1->voxelSize[2] = viewStr->voxelSize[2];
viewStr1->voxelRescaleFlg = viewStr->voxelRescaleFlg;
viewStr1->interp = viewStr->interp;
viewStr1->view_mode = viewStr->view_mode;
viewStr1->up = viewStr->up;
/* now intialize it */
/* could optimise by setting fixed point to object centre */
if( (errNum = WlzInit3DViewStruct(viewStr1, obj)) != WLZ_ERR_NONE ){
WlzFree3DViewStruct(viewStr1);
viewStr1 = NULL;
}
}
}
/* set up orthogonal line parameters & luts */
if( errNum == WLZ_ERR_NONE ){
length = WLZ_NINT(viewStr1->maxvals.vtZ) -
WLZ_NINT(viewStr1->minvals.vtZ) + 1;
s_to_x = (double *) AlcMalloc(sizeof(double) * length );
s_to_y = (double *) AlcMalloc(sizeof(double) * length );
s_to_z = (double *) AlcMalloc(sizeof(double) * length );
/* transform a perpendicular vector */
vtx.vtX = 0.0;
vtx.vtY = 0.0;
vtx.vtZ = 1.0;
Wlz3DSectionTransformInvVtx(&vtx, viewStr1);
vtx1.vtX = 0.0;
vtx1.vtY = 0.0;
vtx1.vtZ = 0.0;
Wlz3DSectionTransformInvVtx(&vtx1, viewStr1);
vtx.vtX -= vtx1.vtX;
vtx.vtY -= vtx1.vtY;
vtx.vtZ -= vtx1.vtZ;
/* assign lut values */
s = (int )(WLZ_NINT(viewStr1->minvals.vtZ) - viewStr1->dist);
for(sp=0; sp < length; sp++, s++){
s_to_x[sp] = s * vtx.vtX;
s_to_y[sp] = s * vtx.vtY;
s_to_z[sp] = s * vtx.vtZ;
}
}
/* if there is an integration function then allocate space for
the grey-level array */
if( (errNum == WLZ_ERR_NONE) && (intFunc) ){
srcGType = WlzGreyTypeFromObj(obj, &errNum);
switch( srcGType ){
case WLZ_GREY_LONG:
size = sizeof(WlzLong)*length;
break;
case WLZ_GREY_INT:
size = sizeof(int)*length;
break;
case WLZ_GREY_SHORT:
size = sizeof(short)*length;
break;
case WLZ_GREY_UBYTE:
size = sizeof(WlzUByte)*length;
break;
case WLZ_GREY_FLOAT:
size = sizeof(float)*length;
break;
case WLZ_GREY_DOUBLE:
size = sizeof(double)*length;
break;
case WLZ_GREY_RGBA:
size = sizeof(int)*length;
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
if( (pixptr.p.inp = (int *) AlcMalloc(size)) == NULL ){
errNum = WLZ_ERR_MEM_ALLOC;
}
pixptr.type = srcGType;
/* set up the grey-value workspace for random access */
gVWSp = WlzGreyValueMakeWSp(obj, &errNum);
}
/* create rectangular projection image */
if( errNum == WLZ_ERR_NONE ){
if((domain.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_RECT,
WLZ_NINT(viewStr1->minvals.vtY),
WLZ_NINT(viewStr1->maxvals.vtY),
WLZ_NINT(viewStr1->minvals.vtX),
WLZ_NINT(viewStr1->maxvals.vtX),
&errNum)) != NULL){
values.core = NULL;
if((rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, values, NULL, NULL,
&errNum)) != NULL){
/* note the grey-values required are determined by the integration
function. Here we use WlzUByte and reset later if needed */
dstGType = WLZ_GREY_UBYTE;
pixval.type = WLZ_GREY_UBYTE;
pixval.v.ubv = (WlzUByte )0;
if((values.v = WlzNewValueTb(rtnObj,
WlzGreyTableType(WLZ_GREY_TAB_RECT,
dstGType, NULL),
pixval, &errNum)) != NULL){
rtnObj->values = WlzAssignValues(values, &errNum);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
else {
WlzFreeDomain(domain);
domain.core = NULL;
}
}
}
/* scan image setting values */
if( errNum == WLZ_ERR_NONE ){
errNum = WlzInitGreyScan(rtnObj, &iwsp, &gwsp);
}
if( errNum == WLZ_ERR_NONE ){
while( (errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE ){
yp = iwsp.linpos - WLZ_NINT(viewStr1->minvals.vtY);
for(k=iwsp.lftpos; k <= iwsp.rgtpos; k++){
xp = k - WLZ_NINT(viewStr1->minvals.vtX);
vtx.vtX = viewStr1->xp_to_x[xp] + viewStr1->yp_to_x[yp];
vtx.vtY = viewStr1->xp_to_y[xp] + viewStr1->yp_to_y[yp];
vtx.vtZ = viewStr1->xp_to_z[xp] + viewStr1->yp_to_z[yp];
/* get the projection values */
/* if no function then just check for occupancy */
if( intFunc == NULL ){
occupiedFlg = 0;
sp = (int )(viewStr1->dist - WLZ_NINT(viewStr1->minvals.vtZ));
for(; !occupiedFlg && (sp < length); sp++){
x = vtx.vtX + s_to_x[sp];
y = vtx.vtY + s_to_y[sp];
z = vtx.vtZ + s_to_z[sp];
if( WlzInsideDomain(obj, z, y, x, &errNum) ){
occupiedFlg = 1;
}
}
sp = (int )(viewStr1->dist - WLZ_NINT(viewStr1->minvals.vtZ) - 1);
for(; !occupiedFlg && (sp >= 0); sp--){
x = vtx.vtX + s_to_x[sp];
y = vtx.vtY + s_to_y[sp];
z = vtx.vtZ + s_to_z[sp];
if( WlzInsideDomain(obj, z, y, x, &errNum) ){
occupiedFlg = 1;
}
}
/* set the integrated value - only WlzUByte at the moment */
*(gwsp.u_grintptr.ubp) = (WlzUByte )occupiedFlg;
gwsp.u_grintptr.ubp++;
}
/* use integration function */
else {
/* set array of pixel values */
for(sp=0; sp < length; sp++){
x = vtx.vtX + s_to_x[sp];
y = vtx.vtY + s_to_y[sp];
z = vtx.vtZ + s_to_z[sp];
WlzGreyValueGet(gVWSp, WLZ_NINT(z), WLZ_NINT(y),
WLZ_NINT(x));
switch( srcGType ){
case WLZ_GREY_LONG:
pixptr.p.lnp[sp] = gVWSp->gVal[0].lnv;
break;
case WLZ_GREY_INT:
pixptr.p.inp[sp] = gVWSp->gVal[0].inv;
break;
case WLZ_GREY_SHORT:
pixptr.p.shp[sp] = gVWSp->gVal[0].shv;
break;
case WLZ_GREY_UBYTE:
pixptr.p.ubp[sp] = gVWSp->gVal[0].ubv;
break;
case WLZ_GREY_FLOAT:
pixptr.p.flp[sp] = gVWSp->gVal[0].flv;
break;
case WLZ_GREY_DOUBLE:
pixptr.p.dbp[sp] = gVWSp->gVal[0].dbv;
break;
case WLZ_GREY_RGBA:
pixptr.p.rgbp[sp] = gVWSp->gVal[0].rgbv;
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
/* call integration function and seet value */
intFunc(pixptr, length, (int )(viewStr1->dist -
WLZ_NINT(viewStr1->minvals.vtZ)),
intFuncData, &errNum);
}
}
}
(void )WlzEndGreyScan(&iwsp, &gwsp);
if(errNum == WLZ_ERR_EOO) /* Reset error from end of intervals */
{
errNum = WLZ_ERR_NONE;
}
/* if no integration function then threshold - binary only */
if( intFunc == NULL ){
pixval.v.ubv = 1;
rtnObj = WlzAssignObject(rtnObj, NULL);
if((obj1 = WlzThreshold(rtnObj, pixval, WLZ_THRESH_HIGH,
&errNum)) != NULL){
WlzFreeObj(rtnObj);
values.core = NULL;
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, obj1->domain, values, NULL, NULL,
&errNum);
WlzFreeObj(obj1);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
}
/* clear space */
if( viewStr1 ){
errNum = WlzFree3DViewStruct(viewStr1);
}
if( s_to_x ){
AlcFree( s_to_x );
}
if( s_to_y ){
AlcFree( s_to_y );
}
if( s_to_z ){
AlcFree( s_to_z );
}
/* check error and return */
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \return Object with transformed grey-values.
* \ingroup WlzArithmetic
* \brief Apply a binary operation (add subtract etc) to
* each pixel value in the given object. The operand value
* is in <tt>pval</tt>.
* \param o1 Input object
* \param pval Pixel value for binary operation.
* \param op Opertor
* \param dstErr Error return.
* \par Source:
* WlzScalarArithmeticOp.c
*/
WlzObject *WlzScalarBinaryOp2(
WlzObject *o1,
WlzPixelV pval,
WlzBinaryOperatorType op,
WlzErrorNum *dstErr)
{
WlzObject *obj=NULL, *tmp3;
WlzErrorNum errNum=WLZ_ERR_NONE;
WlzValues values;
WlzPixelV old_bckgrnd, new_bckgrnd;
WlzGreyType new_grey_type;
int p;
/* check object pointers */
if( (o1 == NULL) ){
errNum = WLZ_ERR_OBJECT_NULL;
}
/* check object types - WLZ_EMPTY_OBJ is legal */
if( errNum == WLZ_ERR_NONE ){
switch( o1->type ){
case WLZ_2D_DOMAINOBJ: /* FALLTHROUGH */
case WLZ_3D_DOMAINOBJ: /* FALLTHROUGH */
case WLZ_TRANS_OBJ:
break;
case WLZ_EMPTY_OBJ:
obj = WlzMakeEmpty(&errNum);
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* check domains and valuetables */
if( (errNum == WLZ_ERR_NONE) && (obj == NULL) ){
switch( o1->type ){
case WLZ_2D_DOMAINOBJ:
if( (o1->domain.core == NULL) ){
errNum = WLZ_ERR_DOMAIN_NULL;
break;
}
if( (o1->values.core == NULL) ){
errNum = WLZ_ERR_VALUES_NULL;
break;
}
break;
case WLZ_3D_DOMAINOBJ:
if( (o1->domain.core == NULL) ){
errNum = WLZ_ERR_DOMAIN_NULL;
break;
}
if( (o1->domain.p->type != WLZ_PLANEDOMAIN_DOMAIN) ){
errNum = WLZ_ERR_PLANEDOMAIN_TYPE;
break;
}
if( (o1->values.core == NULL) ){
errNum = WLZ_ERR_VALUES_NULL;
break;
}
if( (o1->values.vox->type != WLZ_VOXELVALUETABLE_GREY) ){
errNum = WLZ_ERR_VOXELVALUES_TYPE;
break;
}
break;
case WLZ_TRANS_OBJ:
if( (o1->domain.core == NULL) ){
errNum = WLZ_ERR_DOMAIN_NULL;
break;
}
if( (o1->values.core == NULL) ){
errNum = WLZ_ERR_VALUES_NULL;
break;
}
if((values.obj = WlzScalarBinaryOp2(o1->values.obj, pval,
op, &errNum)) != NULL){
obj = WlzMakeMain(WLZ_TRANS_OBJ, o1->domain, values,
NULL, NULL, &errNum);
break;
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* set up temporary object */
if((errNum == WLZ_ERR_NONE) && (obj == NULL)){
switch( o1->type ){
case WLZ_2D_DOMAINOBJ:
values.core = NULL;
if( (tmp3 = WlzMakeMain(WLZ_2D_DOMAINOBJ, o1->domain,
values, NULL, NULL, &errNum)) == NULL ){
break;
}
old_bckgrnd = WlzGetBackground(o1, NULL);
switch( WlzGreyTableTypeToGreyType(o1->values.core->type, NULL) ){
case WLZ_GREY_INT: /* FALLTHROUGH */
case WLZ_GREY_SHORT: /* FALLTHROUGH */
case WLZ_GREY_FLOAT: /* FALLTHROUGH */
case WLZ_GREY_DOUBLE:
new_grey_type = WlzGreyTableTypeToGreyType(o1->values.core->type,
NULL);
new_bckgrnd = old_bckgrnd;
break;
case WLZ_GREY_UBYTE:
new_grey_type = WLZ_GREY_SHORT;
new_bckgrnd.type = WLZ_GREY_SHORT;
new_bckgrnd.v.shv = old_bckgrnd.v.ubv;
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
if(errNum == WLZ_ERR_NONE){
values.v = WlzNewValueTb(tmp3,
WlzGreyTableType(WLZ_GREY_TAB_RAGR,
new_grey_type, NULL),
new_bckgrnd, &errNum);
tmp3->values = WlzAssignValues( values, NULL );
}
break;
case WLZ_3D_DOMAINOBJ:
values.core = NULL;
if((tmp3 = WlzMakeMain(WLZ_3D_DOMAINOBJ, o1->domain, values,
NULL, NULL, &errNum)) == NULL){
break;
}
/* now a new destination voxeltable */
old_bckgrnd = WlzGetBackground(o1, NULL);
switch( old_bckgrnd.type ){
case WLZ_GREY_INT: /* FALLTHROUGH */
case WLZ_GREY_SHORT: /* FALLTHROUGH */
case WLZ_GREY_FLOAT: /* FALLTHROUGH */
case WLZ_GREY_DOUBLE:
new_grey_type = old_bckgrnd.type;
new_bckgrnd = old_bckgrnd;
break;
case WLZ_GREY_UBYTE:
new_grey_type = WLZ_GREY_SHORT;
new_bckgrnd.type = WLZ_GREY_SHORT;
new_bckgrnd.v.shv = old_bckgrnd.v.ubv;
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
if(errNum == WLZ_ERR_NONE){
values.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY,
tmp3->domain.p->plane1,
tmp3->domain.p->lastpl,
new_bckgrnd, NULL, &errNum);
if( values.vox == NULL ){break;}
for(p=tmp3->domain.p->plane1; p <= tmp3->domain.p->lastpl; p++){
WlzValues values2d;
/* currently test for NULL domain to imply WLZ_EMPTY_DOMAIN */
if( tmp3->domain.p->domains[p-tmp3->domain.p->plane1].core
== NULL ){
values2d.core = NULL;
}
else {
WlzObject *tmp2d;
values2d.core = NULL;
if((tmp2d = WlzMakeMain(WLZ_2D_DOMAINOBJ,
tmp3->domain.p->domains[p-tmp3->domain.p->plane1],
values2d, NULL, NULL, &errNum)) != NULL){
values2d.v = WlzNewValueTb(
tmp2d, WlzGreyTableType(WLZ_GREY_TAB_RAGR, new_grey_type,
NULL), new_bckgrnd, &errNum);
WlzFreeObj( tmp2d );
}
}
values.vox->values[p-tmp3->domain.p->plane1] =
WlzAssignValues(values2d, NULL);
}
tmp3->values = WlzAssignValues(values, NULL);
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* apply operation and free space */
if((errNum == WLZ_ERR_NONE) && (obj == NULL)){
if((errNum = WlzScalarBinaryOp(o1, pval, tmp3, op)) != WLZ_ERR_NONE){
WlzFreeObj( tmp3 );
}
else {
obj = tmp3;
}
}
if( dstErr ){
*dstErr = errNum;
}
return obj;
}
/*!
* \ingroup WlzValuesUtils
* \brief Calculate the modulus of the rgb values and return
in an image of grey type WLZ_GREY_SHORT
*
* \return Grey-level object of modulus values
* \param obj Input rgba object
* \param dstErr error return
* \par Source:
* WlzRGBAConvert.c
*/
WlzObject *WlzRGBAToModulus(
WlzObject *obj,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check object type, and value type */
if( obj ){
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if ( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( WlzGreyTypeFromObj(obj, &errNum) != WLZ_GREY_RGBA ){
errNum = WLZ_ERR_VALUES_TYPE;
}
break;
case WLZ_3D_DOMAINOBJ:
if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if( obj->domain.p->type != WLZ_PLANEDOMAIN_DOMAIN ){
errNum = WLZ_ERR_DOMAIN_TYPE;
}
else if ( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( obj->values.vox->type != WLZ_VOXELVALUETABLE_GREY ){
errNum = WLZ_ERR_VALUES_TYPE;
}
else if( WlzGreyTypeFromObj(obj, &errNum) != WLZ_GREY_RGBA ){
errNum = WLZ_ERR_VALUES_TYPE;
}
return WlzRGBAToModulus3D(obj, dstErr);
case WLZ_TRANS_OBJ:
/* not difficult, do it later */
errNum = WLZ_ERR_OBJECT_TYPE;
break;
case WLZ_COMPOUND_ARR_1:
case WLZ_COMPOUND_ARR_2:
/* bit recursive this ! */
errNum = WLZ_ERR_OBJECT_TYPE;
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
}
}
else {
errNum = WLZ_ERR_OBJECT_NULL;
}
/* create object return */
if( errNum == WLZ_ERR_NONE ){
WlzValues values;
WlzObjectType type;
WlzPixelV oldBck, newBck;
type = WlzGreyTableType(
WlzGreyTableTypeToTableType(obj->values.core->type, &errNum),
WLZ_GREY_SHORT, &errNum);
oldBck = WlzGetBackground(obj, &errNum);
newBck.type = WLZ_GREY_SHORT;
newBck.v.shv = (short )WLZ_RGBA_MODULUS(oldBck.v.rgbv);
/* make values table and return object */
values.v = WlzNewValueTb(obj, type, newBck, &errNum);
rtnObj = WlzMakeMain(obj->type, obj->domain, values,
NULL, NULL, &errNum);
}
/* iterate through objects setting values */
if( errNum == WLZ_ERR_NONE ){
WlzIntervalWSpace iwsp0, iwsp1;
WlzGreyWSpace gwsp0, gwsp1;
int j, k;
errNum = WlzInitGreyScan(obj, &iwsp0, &gwsp0);
errNum = WlzInitGreyScan(rtnObj, &iwsp1, &gwsp1);
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp0)) == WLZ_ERR_NONE)){
errNum = WlzNextGreyInterval(&iwsp1);
for(j=0, k=iwsp0.lftpos; k <= iwsp0.rgtpos; j++, k++,
gwsp0.u_grintptr.rgbp++){
*(gwsp1.u_grintptr.shp++) = (short )
WLZ_RGBA_MODULUS(*(gwsp0.u_grintptr.rgbp));
}
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \return New woolz object or NULL on error.
* \ingroup WlzArithmetic
* \brief Scales the values of the given 2D Woolz object so that
* \f$v_{new} = m v_{given} + a.\f$ The input object is known
* to be a valid 2D domain object with grey values.
* \param iObj Given object.
* \param m Value to multiply object values by.
* \param a Value to add to product.
* \param rGType Required grey type for returned object.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzScalarMulAdd2D(WlzObject *iObj, WlzPixelV m, WlzPixelV a,
WlzGreyType rGType, WlzErrorNum *dstErr)
{
WlzValues rValues;
WlzObjectType rVType;
WlzPixelV bgdV;
WlzObject *rObj = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
rValues.core = NULL;
bgdV = WlzGetBackground(iObj, &errNum);
if(errNum == WLZ_ERR_NONE)
{
rVType = WlzGreyTableTypeToTableType(iObj->values.v->type, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
rVType = WlzGreyTableType(rVType, rGType, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
rValues.v = WlzNewValueTb(iObj, rVType, bgdV, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
rObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, iObj->domain, rValues,
iObj->plist, iObj->assoc, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
switch(rGType)
{
case WLZ_GREY_INT: /* FALLTHROUGH */
case WLZ_GREY_SHORT: /* FALLTHROUGH */
case WLZ_GREY_UBYTE: /* FALLTHROUGH */
case WLZ_GREY_RGBA: /* FALLTHROUGH */
case WLZ_GREY_FLOAT: /* FALLTHROUGH */
case WLZ_GREY_DOUBLE:
WlzValueConvertPixel(&m, m, WLZ_GREY_DOUBLE);
WlzValueConvertPixel(&a, a, WLZ_GREY_DOUBLE);
errNum = WlzScalarMulAddSet2D(rObj, iObj, m.v.dbv, a.v.dbv);
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
if(errNum != WLZ_ERR_NONE)
{
if(rObj == NULL)
{
(void )WlzFreeValueTb(rValues.v);
}
else
{
(void )WlzFreeObj(rObj);
rObj = NULL;
}
}
if(dstErr != NULL)
{
*dstErr = errNum;
}
return(rObj);
}
/*!
* \ingroup WlzValuesUtils
* \brief Convert a grey-level woolz object to RGBA via
a colourmap look-up table. Values are clamped to [0,255] and the
LUT is assumed to be unsigned byte 3x256
*
* \return Woolz object
* \param obj Input object to be converted
* \param colormap Colourmap array
* \param dstErr Error return
* \par Source:
* WlzRGBAConvert.c
*/
WlzObject *WlzIndexToRGBA(
WlzObject *obj,
unsigned char colormap[3][256],
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzGreyType oldpixtype;
WlzGreyP go, gn;
WlzIntervalWSpace oldiwsp, newiwsp;
WlzGreyWSpace oldgwsp, newgwsp;
WlzObjectType newvtbltype;
WlzPixelV bg;
WlzValues values;
int k, greyVal, redVal, greenVal, blueVal;
unsigned int rgbaVal;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check object - must be domain object with a values table */
if( obj ){
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->domain.core ){
if( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else {
oldpixtype =
WlzGreyTableTypeToGreyType(obj->values.core->type, NULL);
if( oldpixtype == WLZ_GREY_RGBA ){
return WlzMakeMain(obj->type, obj->domain, obj->values,
NULL, NULL, dstErr);
}
}
}
else {
errNum = WLZ_ERR_DOMAIN_NULL;
}
break;
case WLZ_3D_DOMAINOBJ:
return WlzIndexToRGBA3D(obj, colormap, dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
else {
errNum = WLZ_ERR_OBJECT_NULL;
}
/*
* Set type of new value table so as to preserve
* rectangular/single interval/multiple interval
* type.
*/
if( errNum == WLZ_ERR_NONE ){
newvtbltype = WlzGreyTableTypeToTableType(obj->values.core->type,
&errNum);
}
if( errNum == WLZ_ERR_NONE ){
newvtbltype = WlzGreyTableType(newvtbltype, WLZ_GREY_RGBA, &errNum);
}
/* get the background - note background now carries its own type */
if( errNum == WLZ_ERR_NONE ){
bg = WlzGetBackground(obj, &errNum);
switch( bg.type ){
case WLZ_GREY_INT:
greyVal = WLZ_CLAMP(bg.v.inv, 0, 255);
break;
case WLZ_GREY_SHORT:
greyVal = WLZ_CLAMP(bg.v.shv, 0, 255);
break;
case WLZ_GREY_UBYTE:
greyVal = bg.v.ubv;
break;
case WLZ_GREY_FLOAT:
greyVal = WLZ_CLAMP(bg.v.flv, 0, 255);
break;
case WLZ_GREY_DOUBLE:
greyVal = (int )WLZ_CLAMP(bg.v.dbv, 0, 255);
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
bg.type = WLZ_GREY_RGBA;
WLZ_RGBA_RGBA_SET(bg.v.rgbv, colormap[0][greyVal],
colormap[1][greyVal], colormap[2][greyVal],
255);
}
/*
* Make the new object with new value table type and value table
* allocated (but blank). Share original idom.
*/
if( errNum == WLZ_ERR_NONE ){
values.v = WlzNewValueTb(obj, newvtbltype, bg, &errNum);
}
if( errNum == WLZ_ERR_NONE ){
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, obj->domain, values,
obj->plist, obj->assoc, &errNum);
}
if( errNum == WLZ_ERR_NONE ){
errNum = WlzInitGreyScan(obj, &oldiwsp, &oldgwsp);
}
if( errNum == WLZ_ERR_NONE ){
errNum = WlzInitGreyScan(rtnObj, &newiwsp, &newgwsp);
}
while( ((errNum = WlzNextGreyInterval(&oldiwsp)) == WLZ_ERR_NONE)
&& ((errNum = WlzNextGreyInterval(&newiwsp)) == WLZ_ERR_NONE) ){
go = oldgwsp.u_grintptr;
gn = newgwsp.u_grintptr;
for(k=0; k <= oldiwsp.colrmn; k++){
switch( oldgwsp.pixeltype ){
case WLZ_GREY_INT:
greyVal = WLZ_CLAMP(*(go.inp), 0, 255);
go.inp++;
break;
case WLZ_GREY_SHORT:
greyVal = WLZ_CLAMP(*(go.shp), 0, 255);
go.shp++;
break;
case WLZ_GREY_UBYTE:
greyVal = *(go.ubp);
go.ubp++;
break;
case WLZ_GREY_FLOAT:
greyVal = WLZ_CLAMP(*(go.flp), 0, 255);
go.flp++;
break;
case WLZ_GREY_DOUBLE:
greyVal = (int )WLZ_CLAMP(*(go.dbp), 0, 255);
go.dbp++;
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
redVal = colormap[0][greyVal];
greenVal = colormap[1][greyVal];
blueVal = colormap[2][greyVal];
WLZ_RGBA_RGBA_SET(rgbaVal, redVal, greenVal, blueVal, 0xff);
*(gn.rgbp) = rgbaVal;
gn.rgbp++;
}
} /* while */
if(errNum == WLZ_ERR_EOO) /* Reset error from end of intervals */
{
errNum = WLZ_ERR_NONE;
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \return Compound array.
* \ingroup WlzTransform
* \brief Computes a compound array of three objects, the objects
representing the t11, t12 qnd t22 componemts of a tensor.
* \param inobj Given object.
* \param basisTensorTr Basis Function tensor transform
* \param dstErr Destination error pointer, may be
* NULL.
*/
static WlzCompoundArray *WlzBasisFnTensorTransformObjPrv(WlzObject *inObj,
WlzBasisFnTransform *basisTr,
WlzErrorNum *dstErr)
{
WlzObject *objT11 = NULL,
*objT12 = NULL,
*objT22 = NULL;
WlzCompoundArray *cArray = NULL;
WlzValues valuesT11,
valuesT12,
valuesT22;
WlzIntervalWSpace iWsp,
iWspT11,
iWspT12,
iWspT22;
WlzGreyWSpace gWspT11,
gWspT12,
gWspT22;
WlzDVertex2 sVtx;
WlzErrorNum errNum=WLZ_ERR_NONE;
WlzObjectType vType;
WlzGreyP gPixT11,
gPixT12,
gPixT22;
WlzPixelV backgrnd;
WlzFnType basisFnType;
double t11Partial,
t12APartial,
t12BPartial,
t22Partial;
int k,
l;
valuesT11.core = NULL;
valuesT12.core = NULL;
valuesT22.core = NULL;
basisFnType = basisTr->basisFn->type;
/* Create value tables for the two objects */
vType = WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_FLOAT, NULL);
backgrnd.type = WLZ_GREY_FLOAT;
backgrnd.v.inv = 0;
if((valuesT11.v = WlzNewValueTb(inObj, vType, backgrnd, &errNum)) != NULL)
{
if((valuesT12.v = WlzNewValueTb(inObj, vType, backgrnd, &errNum)) != NULL)
{
valuesT22.v = WlzNewValueTb(inObj, vType, backgrnd, &errNum);
}
else
{
WlzFreeValueTb(valuesT11.v);
WlzFreeValueTb(valuesT12.v);
}
}
else
{
WlzFreeValueTb(valuesT11.v);
}
/* create three Wlz objects to hold t11, t22 and t12 tensor components */
if (errNum == WLZ_ERR_NONE)
{
if ((objT11 = WlzMakeMain(inObj->type, inObj->domain, valuesT11, NULL,
NULL, &errNum)) != NULL)
{
if ((objT12 = WlzMakeMain(inObj->type, inObj->domain, valuesT12, NULL,
NULL, &errNum)) != NULL)
{
if ((objT22 = WlzMakeMain(inObj->type, inObj->domain, valuesT22,
NULL, NULL, &errNum)) == NULL)
{
WlzFreeObj(objT11);
objT11 = NULL;
WlzFreeObj(objT12);
objT12 = NULL;
}
}
else
{
WlzFreeObj(objT11);
objT11 = NULL;
}
}
}
/* initialise workspaces */
if (errNum == WLZ_ERR_NONE)
{
if ((errNum = WlzInitRasterScan(inObj, &iWsp, WLZ_RASTERDIR_ILIC)) ==
WLZ_ERR_NONE)
{
if ((errNum = WlzInitGreyScan(objT11, &iWspT11, &gWspT11)) ==
WLZ_ERR_NONE)
{
if ((errNum = WlzInitGreyScan(objT12, &iWspT12, &gWspT12)) ==
WLZ_ERR_NONE)
{
errNum = WlzInitGreyScan(objT22, &iWspT22, &gWspT22);
}
}
}
}
/* Calculate tensor components for MQ2 only */
if (errNum == WLZ_ERR_NONE)
{
switch (basisFnType)
{
case WLZ_FN_BASIS_2DMQ:
while(((errNum = WlzNextInterval(&iWsp)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iWspT11)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iWspT12)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iWspT22)) == WLZ_ERR_NONE))
{
gPixT11 = gWspT11.u_grintptr;
gPixT12 = gWspT12.u_grintptr;
gPixT22 = gWspT22.u_grintptr;
l = iWsp.linpos;
for (k = iWsp.lftpos; k <= iWsp.rgtpos; k++)
{
sVtx.vtX = k;
sVtx.vtY = l;
t11Partial = WlzBasisFnValueMQ2DPrv(basisTr->basisFn, sVtx, 0);
*(gPixT11.flp) = (float)t11Partial;
++(gPixT11.flp);
t22Partial = WlzBasisFnValueMQ2DPrv(basisTr->basisFn, sVtx, 1);
*(gPixT22.flp) = (float)t22Partial;
++(gPixT22.flp);
t12APartial = WlzBasisFnValueMQ2DPrv(basisTr->basisFn, sVtx, 2);
t12BPartial = WlzBasisFnValueMQ2DPrv(basisTr->basisFn, sVtx, 3);
*(gPixT12.flp) = 0.5 * ((float)t12APartial + (float)t12BPartial);
++(gPixT12.flp);
}
}
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
break;
case WLZ_FN_BASIS_2DTPS:
while(((errNum = WlzNextInterval(&iWsp)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iWspT11)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iWspT12)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iWspT22)) == WLZ_ERR_NONE))
{
gPixT11 = gWspT11.u_grintptr;
gPixT12 = gWspT12.u_grintptr;
gPixT22 = gWspT22.u_grintptr;
l = iWsp.linpos;
for (k = iWsp.lftpos; k <= iWsp.rgtpos; k++)
{
sVtx.vtX = k;
sVtx.vtY = l;
t11Partial = WlzBasisFnValueTPS2DPrv(basisTr->basisFn, sVtx, 0);
*(gPixT11.flp) = (float)t11Partial;
++(gPixT11.flp);
t22Partial = WlzBasisFnValueTPS2DPrv(basisTr->basisFn, sVtx, 1);
*(gPixT22.flp) = (float)t22Partial;
++(gPixT22.flp);
t12APartial = WlzBasisFnValueTPS2DPrv(basisTr->basisFn, sVtx, 2);
t12BPartial = WlzBasisFnValueTPS2DPrv(basisTr->basisFn, sVtx, 3);
*(gPixT12.flp) = 0.5 * ((float)t12APartial + (float)t12BPartial);
++(gPixT12.flp);
}
}
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
break;
default:
errNum = WLZ_ERR_TRANSFORM_TYPE;
break;
}
}
/* create compound object */
if (errNum == WLZ_ERR_NONE)
{
cArray = WlzMakeCompoundArray(WLZ_COMPOUND_ARR_1, 1, 3, NULL,
objT11->type, &errNum);
if (errNum == WLZ_ERR_NONE)
{
cArray->o[0] = WlzAssignObject(objT11, NULL);
cArray->o[1] = WlzAssignObject(objT22, NULL);
cArray->o[2] = WlzAssignObject(objT12, NULL);
}
}
if(dstErr)
{
*dstErr = errNum;
}
return(cArray);
}
/*!
* \ingroup WlzValuesUtils
* \brief Convert a RGBA image to a compound object. The RGBA
* channels are at array indices 0,1,2,3 respectively
* and the sub-object grey types will be WLZ_GREY_UBYTE.
*
* \return Compound array of rgba values
* \param obj Input domain object with value type
* WLZ_GREY_RGBA
* \param colSpc The colour space.
* \param dstErr Destination error ponyer, may be NULL.
*/
WlzCompoundArray *WlzRGBAToCompound(
WlzObject *obj,
WlzRGBAColorSpace colSpc,
WlzErrorNum *dstErr)
{
WlzCompoundArray *cobj=NULL;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check object type, and value type */
if( obj ){
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if ( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( WlzGreyTypeFromObj(obj, &errNum) != WLZ_GREY_RGBA ){
errNum = WLZ_ERR_VALUES_TYPE;
}
break;
case WLZ_3D_DOMAINOBJ:
if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if( obj->domain.p->type != WLZ_PLANEDOMAIN_DOMAIN ){
errNum = WLZ_ERR_DOMAIN_TYPE;
}
else if ( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
else if( obj->values.vox->type != WLZ_VOXELVALUETABLE_GREY ){
errNum = WLZ_ERR_VALUES_TYPE;
}
else if( WlzGreyTypeFromObj(obj, &errNum) != WLZ_GREY_RGBA ){
errNum = WLZ_ERR_VALUES_TYPE;
}
return WlzRGBAToCompound3D(obj, colSpc, dstErr);
case WLZ_TRANS_OBJ:
/* not difficult, do it later */
errNum = WLZ_ERR_OBJECT_TYPE;
break;
case WLZ_COMPOUND_ARR_1:
case WLZ_COMPOUND_ARR_2:
/* bit recursive this ! */
errNum = WLZ_ERR_OBJECT_TYPE;
break;
case WLZ_EMPTY_OBJ:
return (WlzCompoundArray *) WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
}
}
else {
errNum = WLZ_ERR_OBJECT_NULL;
}
/* check colour space */
if( errNum == WLZ_ERR_NONE ){
switch( colSpc ){
case WLZ_RGBA_SPACE_RGB:
case WLZ_RGBA_SPACE_HSB:
case WLZ_RGBA_SPACE_CMY:
break;
default:
errNum = WLZ_ERR_PARAM_DATA;
break;
}
}
/* create compound object return */
if( errNum == WLZ_ERR_NONE ){
WlzValues values;
WlzObject *objs[4];
WlzObjectType type;
WlzPixelV oldBck, newBck;
type = WlzGreyTableType(
WlzGreyTableTypeToTableType(obj->values.core->type, &errNum),
WLZ_GREY_UBYTE, &errNum);
oldBck = WlzGetBackground(obj, &errNum);
/* red */
newBck.type = WLZ_GREY_UBYTE;
newBck.v.ubv = (WlzUByte )WLZ_RGBA_RED_GET(oldBck.v.rgbv);
values.v = WlzNewValueTb(obj, type, newBck, &errNum);
objs[0] = WlzMakeMain(obj->type, obj->domain, values,
NULL, NULL, &errNum);
/* green */
newBck.v.ubv = (WlzUByte )WLZ_RGBA_GREEN_GET(oldBck.v.rgbv);
values.v = WlzNewValueTb(obj, type, newBck, &errNum);
objs[1] = WlzMakeMain(obj->type, obj->domain, values,
NULL, NULL, &errNum);
/* blue */
newBck.v.ubv = (WlzUByte )WLZ_RGBA_BLUE_GET(oldBck.v.rgbv);
values.v = WlzNewValueTb(obj, type, newBck, &errNum);
objs[2] = WlzMakeMain(obj->type, obj->domain, values,
NULL, NULL, &errNum);
/* alpha */
newBck.v.ubv = (WlzUByte )WLZ_RGBA_ALPHA_GET(oldBck.v.rgbv);
values.v = WlzNewValueTb(obj, type, newBck, &errNum);
objs[3] = WlzMakeMain(obj->type, obj->domain, values,
NULL, NULL, &errNum);
/* create compound object, object pointers are assigned for mode=3
so no need to free objects */
cobj = WlzMakeCompoundArray(WLZ_COMPOUND_ARR_1, 3, 4, &(objs[0]),
obj->type, &errNum);
}
/* iterate through objects setting values */
if( errNum == WLZ_ERR_NONE ){
WlzIntervalWSpace iwsp0, iwsp[4];
WlzGreyWSpace gwsp0, gwsp[4];
int i, j, k;
int a, col[3];
errNum = WlzInitGreyScan(obj, &iwsp0, &gwsp0);
for(i=0; i < 4; i++){
errNum = WlzInitGreyScan(cobj->o[i], &(iwsp[i]), &(gwsp[i]));
}
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&iwsp0)) == WLZ_ERR_NONE)){
for(i=0; i < 4; i++){
errNum = WlzNextGreyInterval(&(iwsp[i]));
}
switch( colSpc ){
case WLZ_RGBA_SPACE_RGB:
for(j=0, k=iwsp0.lftpos; k <= iwsp0.rgtpos; j++, k++,
gwsp0.u_grintptr.rgbp++){
*(gwsp[0].u_grintptr.ubp++) =
(WlzUByte )WLZ_RGBA_RED_GET(*(gwsp0.u_grintptr.rgbp));
*(gwsp[1].u_grintptr.ubp++) =
(WlzUByte )WLZ_RGBA_GREEN_GET(*(gwsp0.u_grintptr.rgbp));
*(gwsp[2].u_grintptr.ubp++) =
(WlzUByte )WLZ_RGBA_BLUE_GET(*(gwsp0.u_grintptr.rgbp));
*(gwsp[3].u_grintptr.ubp++) =
(WlzUByte )WLZ_RGBA_ALPHA_GET(*(gwsp0.u_grintptr.rgbp));
}
break;
case WLZ_RGBA_SPACE_HSB: /* each normalised to [0,255] */
for(j=0, k=iwsp0.lftpos; k <= iwsp0.rgtpos; j++, k++,
gwsp0.u_grintptr.rgbp++){
col[0] = WLZ_RGBA_RED_GET(*(gwsp0.u_grintptr.rgbp));
col[1] = WLZ_RGBA_GREEN_GET(*(gwsp0.u_grintptr.rgbp));
col[2] = WLZ_RGBA_BLUE_GET(*(gwsp0.u_grintptr.rgbp));
a = WLZ_RGBA_ALPHA_GET(*(gwsp0.u_grintptr.rgbp));
WlzRGBAConvertRGBToHSV_UBYTENormalised(col);
*(gwsp[0].u_grintptr.ubp++) = (WlzUByte )(col[0]);
*(gwsp[1].u_grintptr.ubp++) = (WlzUByte )(col[1]);
*(gwsp[2].u_grintptr.ubp++) = (WlzUByte )(col[2]);
*(gwsp[3].u_grintptr.ubp++) = (WlzUByte )a;
}
break;
case WLZ_RGBA_SPACE_CMY:
for(j=0, k=iwsp0.lftpos; k <= iwsp0.rgtpos; j++, k++,
gwsp0.u_grintptr.rgbp++){
col[0] = WLZ_RGBA_RED_GET(*(gwsp0.u_grintptr.rgbp));
col[1] = WLZ_RGBA_GREEN_GET(*(gwsp0.u_grintptr.rgbp));
col[2] = WLZ_RGBA_BLUE_GET(*(gwsp0.u_grintptr.rgbp));
a = WLZ_RGBA_ALPHA_GET(*(gwsp0.u_grintptr.rgbp));
*(gwsp[0].u_grintptr.ubp++) = (WlzUByte )((col[1] + col[2]) / 2);
*(gwsp[1].u_grintptr.ubp++) = (WlzUByte )((col[2] + col[0]) / 2);
*(gwsp[2].u_grintptr.ubp++) = (WlzUByte )((col[0] + col[1]) / 2);
*(gwsp[3].u_grintptr.ubp++) = (WlzUByte )a;
}
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
}
if( dstErr ){
*dstErr = errNum;
}
return cobj;
}
/*!
* \return Rescaled object.
* \ingroup WlzTransform
* \brief Rescales the given 2D domain object using an integer scale.
* \param obj Given object.
* \param scale Integer scale factor.
* \param expand If zero use \f$\frac{1}{scale}\f$.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzIntRescaleObj2D(
WlzObject *obj,
int scale,
int expand,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzDomain domain;
WlzValues values;
WlzInterval *intvls;
int k1, kl, l1, ll, l, num_intvls;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check expand or contract */
if( expand )
{
k1 = obj->domain.i->kol1 * scale;
kl = obj->domain.i->lastkl * scale + scale - 1;
l1 = obj->domain.i->line1 * scale;
ll = obj->domain.i->lastln * scale + scale - 1;
}
else {
k1 = obj->domain.i->kol1 / scale;
kl = obj->domain.i->lastkl / scale;
l1 = obj->domain.i->line1 / scale;
ll = obj->domain.i->lastln / scale;
}
/* create a new object */
if((domain.i = WlzMakeIntervalDomain(obj->domain.i->type,
l1, ll, k1, kl, &errNum)) != NULL){
values.core = NULL;
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, values,
NULL, NULL, NULL);
}
/* fill in the intervals */
if( errNum == WLZ_ERR_NONE){
if( domain.i->type == WLZ_INTERVALDOMAIN_INTVL )
{
int intvline_offset, max_offset;
WlzIntervalLine *intvline;
num_intvls = WlzIntervalCount(obj->domain.i, NULL);
num_intvls = expand ? num_intvls * scale : num_intvls;
intvls = (WlzInterval *)AlcMalloc(sizeof(WlzInterval) * num_intvls);
domain.i->freeptr = AlcFreeStackPush(domain.i->freeptr, (void *)intvls,
NULL);
max_offset = obj->domain.i->lastln - obj->domain.i->line1;
for(l=l1; l <= ll; l++)
{
int i;
intvline_offset = (expand?l/scale:l*scale) - obj->domain.i->line1;
intvline_offset = WLZ_MAX(intvline_offset, 0);
intvline_offset = WLZ_MIN(intvline_offset, max_offset);
intvline = obj->domain.i->intvlines + intvline_offset;
for(i=0; i < intvline->nintvs; i++)
{
intvls[i].ileft = (intvline->intvs + i)->ileft;
intvls[i].iright = (intvline->intvs + i)->iright;
if( expand )
{
intvls[i].ileft *= scale;
intvls[i].iright *= scale;
intvls[i].iright += scale - 1;
}
else
{
intvls[i].ileft /= scale;
intvls[i].iright /= scale;
}
}
i = check_intvs(intvls, i);
WlzMakeInterval(l, domain.i, i, intvls);
intvls += i;
}
(void) WlzStandardIntervalDomain( domain.i );
}
}
/* create the valuetable */
if( (errNum == WLZ_ERR_NONE) && obj->values.core )
{
WlzIntervalWSpace iwsp;
WlzGreyWSpace gwsp;
WlzPixelV backgrnd;
WlzGreyValueWSpace *gVWSp = NULL;
WlzGreyType gtype;
backgrnd = WlzGetBackground(obj, NULL);
if((values.v = WlzNewValueTb(rtnObj, obj->values.v->type,
backgrnd, &errNum)) != NULL){
rtnObj->values = WlzAssignValues(values, NULL);
/* fill in the grey-values */
errNum = WlzInitGreyScan(rtnObj, &iwsp, &gwsp);
if(errNum == WLZ_ERR_NONE) {
gVWSp = WlzGreyValueMakeWSp(obj, &errNum);
if(errNum == WLZ_ERR_NONE) {
gtype = WlzGreyTableTypeToGreyType(obj->values.v->type, NULL);
}
while((errNum == WLZ_ERR_NONE) &&
(errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE)
{
int k;
int lp = expand ? iwsp.linpos/scale : iwsp.linpos*scale;
for( k=0; k <= (iwsp.rgtpos - iwsp.lftpos); k++ )
{
int kp = expand ? (k+iwsp.lftpos)/scale : (k+iwsp.lftpos)*scale;
WlzGreyValueGet(gVWSp, 0, (double) lp, (double) kp);
switch(gtype)
{
case WLZ_GREY_INT:
gwsp.u_grintptr.inp[k] = (*(gVWSp->gVal)).inv;
break;
case WLZ_GREY_SHORT:
gwsp.u_grintptr.shp[k] = (*(gVWSp->gVal)).shv;
break;
case WLZ_GREY_UBYTE:
gwsp.u_grintptr.ubp[k] = (*(gVWSp->gVal)).ubv;
break;
case WLZ_GREY_FLOAT:
gwsp.u_grintptr.flp[k] = (*(gVWSp->gVal)).flv;
break;
case WLZ_GREY_DOUBLE:
gwsp.u_grintptr.dbp[k] = (*(gVWSp->gVal)).dbv;
break;
case WLZ_GREY_RGBA:
gwsp.u_grintptr.rgbp[k] = (*(gVWSp->gVal)).rgbv;
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
WlzGreyValueFreeWSp(gVWSp);
(void )WlzEndGreyScan(&iwsp, &gwsp);
}
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
int main(int argc, char *argv[])
{
int option,
nReg = 0,
tNReg = 0,
ok = 1,
usage = 0,
verbose = 0,
threshSet = 0,
centreSet = 0;
double minArea = 2;
char *inExt,
*dbgExt,
*inDir,
*dbgDir,
*inFile,
*dbgFile,
*inPath = NULL,
*dbgPath = NULL,
*outFile = NULL;
WlzRadDistVal distSort = WLZ_RADDISTVAL_AREA;
WlzRadDistRec *distData = NULL;
WlzPixelV thrVal;
WlzDVertex2 centre;
WlzCompThreshType thrMtd = WLZ_COMPTHRESH_OTSU;
WlzThresholdType thrMod = WLZ_THRESH_HIGH;
WlzEffFormat inFmt = WLZEFF_FORMAT_NONE,
dbgFmt = WLZEFF_FORMAT_NONE;
WlzObject *inObj = NULL,
*disObj = NULL,
*segObj = NULL;
WlzGreyValueWSpace *disGVWSp = NULL;
WlzObject **regObjs = NULL;
FILE *fP = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
const int maxObj = 1000000;
char pathBuf[FILENAME_MAX];
const double eps = 1.0e-06;
const char *errMsg;
static char optList[] = "hvAGDHELR:c:d:n:o:t:",
defFile[] = "-";
thrVal.type = WLZ_GREY_DOUBLE;
thrVal.v.dbv = 0.0;
outFile = defFile;
while((usage == 0) && ok &&
((option = getopt(argc, argv, optList)) != -1))
{
switch(option)
{
case 'A':
distSort = WLZ_RADDISTVAL_AREA;
break;
case 'D':
distSort = WLZ_RADDISTVAL_DIST;
break;
case 'G':
distSort = WLZ_RADDISTVAL_ANGLE;
break;
case 'H':
thrMod = WLZ_THRESH_HIGH;
break;
case 'E':
thrMod = WLZ_THRESH_EQUAL;
break;
case 'L':
thrMod = WLZ_THRESH_LOW;
break;
case 'R':
distSort = WLZ_RADDISTVAL_RADIUS;
break;
case 'h':
usage = 1;
break;
case 'v':
verbose = 1;
break;
case 'c':
centreSet = 1;
if(sscanf(optarg, "%lg,%lg", &(centre.vtX), &(centre.vtY)) != 2)
{
usage = 1;
}
break;
case 'd':
dbgPath = optarg;
break;
case 'o':
outFile = optarg;
break;
case 'n':
if(sscanf(optarg, "%lg", &minArea) != 1)
{
usage = 1;
}
break;
case 't':
threshSet = 1;
if(sscanf(optarg, "%lg", &(thrVal.v.dbv)) != 1)
{
usage = 1;
}
break;
default:
usage = 1;
break;
}
}
ok = !usage;
if(ok)
{
if((optind + 1) != argc)
{
usage = 1;
ok = 0;
}
else
{
inPath = *(argv + optind);
}
}
if(ok && verbose)
{
(void )fprintf(stderr, "inPath = %s\n", inPath);
}
/* Parse input file path into path + name + ext. */
if(ok)
{
ok = (usage = WlzRadDistParsePath(inPath, &inDir, &inFile, &inExt,
&inFmt)) == 0;
}
if(ok && verbose)
{
(void )fprintf(stderr, "inDir = %s\n", inDir);
(void )fprintf(stderr, "inFile = %s\n", inFile);
(void )fprintf(stderr, "inExt = %s\n", (inExt)? inExt: "(null)");
(void )fprintf(stderr, "inFmt = %s\n",
WlzEffStringFromFormat(inFmt, NULL));
}
/* Read image. */
if(ok)
{
errNum = WLZ_ERR_READ_EOF;
if(inExt)
{
(void )sprintf(pathBuf, "%s/%s.%s", inDir, inFile, inExt);
}
else
{
(void )sprintf(pathBuf, "%s/%s", inDir, inFile);
}
if(((inObj = WlzAssignObject(WlzEffReadObj(NULL, pathBuf, inFmt,
0, 0, 0,
&errNum), NULL)) == NULL) ||
(inObj->type != WLZ_2D_DOMAINOBJ))
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to read 2D image object from file %s (%s)\n",
*argv, pathBuf, errMsg);
}
}
if(ok && verbose)
{
(void )fprintf(stderr, "read input image ok.\n");
}
/* Convert to grey if needed, normalise 0 - 255 if needed and compute
* threshold value unless already known. */
if(ok)
{
if(WlzGreyTypeFromObj(inObj, NULL) == WLZ_GREY_RGBA)
{
WlzObject *ppObj;
ppObj = WlzAssignObject(
WlzRGBAToModulus(inObj, &errNum), NULL);
if(errNum == WLZ_ERR_NONE)
{
(void )WlzFreeObj(inObj);
inObj = ppObj;
}
}
if(threshSet == 0)
{
WlzObject *hObj = NULL;
errNum = WlzGreyNormalise(inObj, 1);
if(errNum == WLZ_ERR_NONE)
{
hObj = WlzHistogramObj(inObj, 256, 0.0, 1.0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
threshSet = 1;
errNum = WlzCompThreshold(&thrVal.v.dbv, hObj, thrMtd, 0);
}
(void )WlzFreeObj(hObj);
}
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr, "%s: failed to normalise object (%s)\n",
*argv, errMsg);
}
}
/* Segment the object. */
if(ok)
{
if(inObj->values.core == NULL)
{
segObj = WlzAssignObject(inObj, NULL);
}
else
{
segObj = WlzAssignObject(
WlzThreshold(inObj, thrVal, thrMod, &errNum), NULL);
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr, "%s: failed to segment image (%s)\n",
*argv, errMsg);
}
}
}
/* Compute object with the same domain as the input object but in which
* the values are the minimum distance from an edge. */
if(ok)
{
WlzObject *bObj = NULL;
bObj = WlzBoundaryDomain(inObj, &errNum);
if(errNum == WLZ_ERR_NONE)
{
disObj = WlzAssignObject(
WlzDistanceTransform(inObj, bObj, WLZ_OCTAGONAL_DISTANCE,
0.0, 0.0, &errNum), NULL);
}
if(errNum == WLZ_ERR_NONE)
{
disGVWSp = WlzGreyValueMakeWSp(disObj, &errNum);
}
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr, "%s: failed to compute distance object (%s)\n",
*argv, errMsg);
}
(void )WlzFreeObj(bObj);
}
/* Output the debug image if required. */
if(ok && dbgPath)
{
WlzObject *dbgObj;
dbgObj = WlzAssignObject(WlzCopyObject(inObj, &errNum), NULL);
if(errNum == WLZ_ERR_NONE)
{
WlzPixelV iMin,
iMax,
oMin,
oMax;
if(dbgObj->values.core == NULL)
{
WlzValues tmpVal;
oMax.type = WLZ_GREY_UBYTE;
oMax.v.ubv = 255;
tmpVal.v = WlzNewValueTb(dbgObj,
WlzGreyTableType(WLZ_GREY_TAB_RAGR,
WLZ_GREY_UBYTE, NULL),
oMax, &errNum);
if(errNum == WLZ_ERR_NONE)
{
dbgObj->values = WlzAssignValues(tmpVal, NULL);
}
}
else
{
WlzObject *tmpObj = NULL;
oMin.type = WLZ_GREY_UBYTE;
oMin.v.ubv = 0;
oMax.type = WLZ_GREY_UBYTE;
oMax.v.ubv = 200;
errNum = WlzGreyRange(dbgObj, &iMin, &iMax);
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzGreySetRange(dbgObj, iMin, iMax, oMin, oMax, 0);
}
if(errNum == WLZ_ERR_NONE)
{
tmpObj = WlzMakeMain(inObj->type, segObj->domain, dbgObj->values,
NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
oMax.v.ubv = 255;
errNum = WlzGreySetValue(tmpObj, oMax);
}
(void )WlzFreeObj(tmpObj);
if(errNum == WLZ_ERR_NONE)
{
tmpObj = WlzConvertPix(dbgObj, WLZ_GREY_UBYTE, &errNum);
(void )WlzFreeObj(dbgObj);
dbgObj = WlzAssignObject(tmpObj, NULL);
}
}
}
if(errNum == WLZ_ERR_NONE)
{
(void )WlzRadDistParsePath(dbgPath, &dbgDir, &dbgFile, &dbgExt,
&dbgFmt);
if(dbgExt)
{
(void )sprintf(pathBuf, "%s/%s.%s", dbgDir, dbgFile, dbgExt);
}
else
{
(void )sprintf(pathBuf, "%s/%s", dbgDir, dbgFile);
}
errNum = WlzEffWriteObj(NULL, pathBuf, dbgObj, dbgFmt);
}
(void )WlzFreeObj(dbgObj);
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr, "%s: failed to output the debug image (%s)\n",
*argv, errMsg);
}
}
/* Label the segmented object. */
if(ok)
{
errNum = WlzLabel(segObj, &nReg, ®Objs, maxObj, 0, WLZ_8_CONNECTED);
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
errNum = WLZ_ERR_MEM_ALLOC;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr, "%s: failed to split into components (%s)\n",
*argv, errMsg);
}
if(ok && verbose)
{
(void )fprintf(stderr, "nReg = %d\n", nReg);
}
}
/* Compute centre of mass if not known. */
if(ok)
{
if(centreSet == 0)
{
centre = WlzCentreOfMass2D(inObj, 1, NULL, &errNum);
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr, "%s: failed to compute centre of mass (%s)\n",
*argv, errMsg);
}
}
if(ok && verbose)
{
(void )fprintf(stderr, "centre = %lg,%lg\n", centre.vtX, centre.vtY);
}
}
/* Allocate a radial distribution table. */
if(ok)
{
if((distData = (WlzRadDistRec *)
AlcCalloc(nReg, sizeof(WlzRadDistRec))) == NULL)
{
ok = 0;
errNum = WLZ_ERR_MEM_ALLOC;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr, "%s: failed to allocate result lable (%s)\n",
*argv, errMsg);
}
}
/* Compute the redial distribution data. */
if(ok)
{
int idR = 0,
idS = 0;
while((errNum == WLZ_ERR_NONE) && (idR < nReg))
{
double mass;
WlzDVertex2 com;
com = WlzCentreOfMass2D(regObjs[idR], 1, &mass, NULL);
if(mass > minArea - eps)
{
WlzGreyValueGet(disGVWSp, 0.0, com.vtY, com.vtX);
distData[idS].pos = com;
distData[idS].area = mass;
WLZ_VTX_2_SUB(com, centre, com);
distData[idS].radius = WLZ_VTX_2_LENGTH(com);
distData[idS].angle = ALG_M_PI + atan2(com.vtY, com.vtX);
switch(disGVWSp->gType)
{
case WLZ_GREY_LONG:
distData[idS].dist = *(disGVWSp->gPtr[0].lnp);
break;
case WLZ_GREY_INT:
distData[idS].dist = *(disGVWSp->gPtr[0].inp);
break;
case WLZ_GREY_SHORT:
distData[idS].dist = *(disGVWSp->gPtr[0].shp);
break;
case WLZ_GREY_UBYTE:
distData[idS].dist = *(disGVWSp->gPtr[0].ubp);
break;
case WLZ_GREY_FLOAT:
distData[idS].dist = *(disGVWSp->gPtr[0].flp);
break;
case WLZ_GREY_DOUBLE:
distData[idS].dist = *(disGVWSp->gPtr[0].dbp);
break;
default:
distData[idS].dist = 0.0;
break;
}
++idS;
}
++idR;
}
tNReg = idS;
switch(distSort)
{
case WLZ_RADDISTVAL_AREA:
(void )qsort(distData, tNReg, sizeof(WlzRadDistRec),
WlzRadDistRecSortArea);
break;
case WLZ_RADDISTVAL_ANGLE:
(void )qsort(distData, tNReg, sizeof(WlzRadDistRec),
WlzRadDistRecSortAngle);
break;
case WLZ_RADDISTVAL_RADIUS:
(void )qsort(distData, tNReg, sizeof(WlzRadDistRec),
WlzRadDistRecSortRadius);
break;
case WLZ_RADDISTVAL_DIST:
(void )qsort(distData, tNReg, sizeof(WlzRadDistRec),
WlzRadDistRecSortDist);
break;
}
}
/* Output the sorted radial distribution table. */
if(ok)
{
if(((fP = strcmp(outFile, "-")?
fopen(outFile, "w"): stdout)) == NULL)
{
ok = 0;
(void )fprintf(stderr, "%s: failed to open output file %s\n",
*argv, outFile);
}
}
if(ok)
{
int idR;
for(idR = 0; idR < tNReg; ++idR)
{
double a;
a = (distData[idR].angle > 0.0)?
0 + (180 * distData[idR].angle / ALG_M_PI):
360 + (180 * distData[idR].angle / ALG_M_PI);
(void )fprintf(fP, "%g %g %g %g,%g %g\n",
a,
distData[idR].radius,
distData[idR].area,
distData[idR].pos.vtX,
distData[idR].pos.vtY,
distData[idR].dist);
}
}
if(strcmp(outFile, "-"))
{
(void )fclose(fP);
}
/* Tidy up. */
AlcFree(distData);
WlzGreyValueFreeWSp(disGVWSp);
(void )WlzFreeObj(inObj);
(void )WlzFreeObj(disObj);
(void )WlzFreeObj(segObj);
if(regObjs)
{
int idR;
for(idR = 0; idR < nReg; ++idR)
{
(void )WlzFreeObj(regObjs[idR]);
}
AlcFree(regObjs);
}
if(usage)
{
(void )fprintf(stderr,
"Usage: %s [-h] [-v] [-A] [-D] [-G] [-H] [-E] [-L] [-R]\n"
"\t\t[-c #,#] [-d <debug image>] [-n #] [-o <out file>]\n"
"\t\t[-t #] [<input image>]\n"
"Segments the given object using a threshold value and outputs the \n"
"radial distribution of the thresholded components.\n"
"Version: %s\n"
"Options:\n"
" -h Help - prints this usage masseage.\n"
" -v Verbose output.\n"
" -A Sort output by area (default).\n"
" -D Sort output by distance from boundary.\n"
" -G Sort output by angle.\n"
" -H Threshold high, use pixels at or above threshold (default).\n"
" -E Threshold equal, use pixels at threshold.\n"
" -L Threshold low, use pixels below threshold.\n"
" -R Sort output by radial distance from centre.\n"
" -c Centre (default is image centre).\n"
" -d Debug image.\n"
" -n Minimum area (default %g).\n"
" -t Threshold value (default is to compute using Otsu's method).\n"
"By default the input image object is read from the standard input and\n"
"the radial distribution is written to the standard output.\n"
"The image formats understood include wlz, jpg and tif.\n"
"The output format is:\n"
" <angle> <dist from centre> <area> <x pos>,<y pos> <dist form boundary>\n"
"Example:\n"
" %s -o out.txt -d debug.jpg in.tif\n"
"The input image is read from in.tif, a debug image showing the\n"
"segmented regions is written to debug.jpg and the radial distribution\n"
"statistics are written to the file out.txt. With the output in\n"
"out.txt, the following R code would plot the data as a set of circles\n"
"with radius proportional to the square root of the component area:\n"
" data <- read.table(\"out.txt\")\n"
" attach(data)\n"
" symbols(x=data$V1, y=data$V2, circles=sqrt(data$V3))\n",
argv[0],
WlzVersion(),
minArea,
argv[0]);
}
return(!ok);
}
/*!
* \return New object or NULL on error.
* \ingroup WlzValuesUtils
* \brief Transfers grey values from the source object to the
* destination object within the intersection of the source
* and destination. Grey values within the destination
* object outside of the source object are unchanged.
* It is an error if either object has a different dimension
* or grey value type, except for when either is an empty
* object.
* \param dObj Destination object which may be
* empty, but otherwise should be of the
* same dimension as the source object
* with valid values..
* \param sObj Source object which if not empty must
* have both a valid domain and valid
* values.
* \param inplace Overwrite the destination object's
* values if non zero.
* \param dstErr Destination error pointer, may be NULL.
*/
WlzObject *WlzGreyTransfer(
WlzObject *dObj,
WlzObject *sObj,
int inplace,
WlzErrorNum *dstErr)
{
WlzObject *rObj = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
if((dObj == NULL) || (sObj == NULL))
{
errNum = WLZ_ERR_OBJECT_NULL;
}
else if(WlzIsEmpty(dObj, NULL))
{
rObj = WlzMakeEmpty(&errNum);
}
else if(WlzIsEmpty(sObj, NULL))
{
rObj = WlzMakeMain(dObj->type, dObj->domain, dObj->values,
dObj->plist, NULL, &errNum);
}
else if(dObj->type != sObj->type)
{
errNum = WLZ_ERR_OBJECT_TYPE;
}
else if((dObj->domain.core == NULL) || (sObj->domain.core == NULL))
{
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if(sObj->values.core == NULL)
{
errNum = WLZ_ERR_VALUES_NULL;
}
else
{
switch(sObj->type)
{
case WLZ_2D_DOMAINOBJ:
case WLZ_3D_DOMAINOBJ: /* FALLTHROUGH */
{
WlzObject *rIObj = NULL;
rIObj = WlzIntersect2(dObj, sObj, &errNum);
if((errNum == WLZ_ERR_NONE) && (WlzIsEmpty(rIObj, NULL) == 0))
{
rObj = (inplace)?
WlzMakeMain(dObj->type, dObj->domain, dObj->values,
dObj->plist, NULL, &errNum):
WlzCopyObject(dObj, &errNum);
if(errNum == WLZ_ERR_NONE)
{
/* If the destination object does not have values then
* create them to match the domain of the destination
* object. */
if((sObj->values.core != NULL) && (rObj->values.core == NULL))
{
WlzPixelV bgdV;
WlzGreyType gType;
WlzObjectType gTT;
WlzValues newVal;
newVal.core = NULL;
bgdV = WlzGetBackground(sObj, &errNum);
if(errNum == WLZ_ERR_NONE)
{
gType = WlzGreyTypeFromObj(sObj, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
gTT = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gType, NULL);
if(rObj->type == WLZ_2D_DOMAINOBJ)
{
newVal.v = WlzNewValueTb(rObj, gTT, bgdV, &errNum);
}
else /* rObj->type == WLZ_3D_DOMAINOBJ */
{
newVal.vox = WlzNewValuesVox(rObj, gTT, bgdV, &errNum);
}
}
if(errNum == WLZ_ERR_NONE)
{
rObj->values = WlzAssignValues(newVal, NULL);
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzGreySetValue(rObj, bgdV);
}
}
}
if(errNum == WLZ_ERR_NONE)
{
if(sObj->type == WLZ_2D_DOMAINOBJ)
{
WlzObject *sIObj;
rIObj->values = WlzAssignValues(rObj->values, NULL);
sIObj = WlzMakeMain(WLZ_2D_DOMAINOBJ,
rIObj->domain, sObj->values,
NULL, NULL, &errNum);
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzGreyTransfer2D(rIObj, sIObj);
}
(void )WlzFreeObj(sIObj);
}
else /* sObj->type == WLZ_3D_DOMAINOBJ */
{
int p,
rTiled,
sTiled,
nPlanes;
rTiled = WlzGreyTableIsTiled(rObj->values.core->type);
sTiled = WlzGreyTableIsTiled(sObj->values.core->type);
nPlanes = rIObj->domain.p->lastpl - rIObj->domain.p->plane1 + 1;
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(p = 0; p < nPlanes; ++p)
{
if(errNum == WLZ_ERR_NONE)
{
int pln;
WlzDomain dom;
WlzValues val;
WlzObject *rIObj2D = NULL,
*sIObj2D = NULL;
WlzErrorNum errNum2D = WLZ_ERR_NONE;
pln = p + rIObj->domain.p->plane1;
dom = rIObj->domain.p->domains[p];
val = (rTiled)?
rObj->values:
rObj->values.vox->values[pln -
rObj->values.vox->plane1];
rIObj2D = WlzMakeMain(WLZ_2D_DOMAINOBJ,
dom, val, NULL, NULL, &errNum2D);
if(errNum2D == WLZ_ERR_NONE)
{
val = (sTiled)?
sObj->values:
sObj->values.vox->values[pln -
sObj->values.vox->plane1];
sIObj2D = WlzMakeMain(WLZ_2D_DOMAINOBJ,
dom, val, NULL, NULL, &errNum2D);
}
if(errNum2D == WLZ_ERR_NONE)
{
errNum2D = WlzGreyTransfer2D(rIObj2D, sIObj2D);
}
(void )WlzFreeObj(rIObj2D);
(void )WlzFreeObj(sIObj2D);
#ifdef _OPENMP
#pragma omp critical
{
#endif
if((errNum == WLZ_ERR_NONE) && (errNum2D != WLZ_ERR_NONE))
{
errNum = errNum2D;
}
#ifdef _OPENMP
}
#endif
}
}
}
}
}
(void )WlzFreeObj(rIObj);
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
if(errNum != WLZ_ERR_NONE)
{
WlzFreeObj(rObj);
rObj = NULL;
}
if(dstErr)
{
*dstErr = errNum;
}
return(rObj);
}
/*!
* \return New 2D domain object.
* \ingroup WlzArithmetic
* \brief Computes a new 2D object which shares the domain of the given
* object, but which has grey values that are the result of
* applying the given function to the grey values of the
* given object.
* \param sObj Given source domain object with values.
* \param fn Scalar function to be applied.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzScalarFn2D(WlzObject *sObj, WlzFnType fn,
WlzErrorNum *dstErr)
{
WlzGreyType sGType,
dGType;
WlzPixelV sBgd,
dBgd;
WlzObjectType dVType;
WlzObject *dObj = NULL;
WlzValues dVal;
WlzIntervalWSpace sIWSp,
dIWSp;
WlzGreyWSpace sGWSp,
dGWSp;
WlzErrorNum errNum = WLZ_ERR_NONE;
sGType = WlzGreyTypeFromObj(sObj, &errNum);
if(errNum == WLZ_ERR_NONE)
{
dGType = WlzScalarFnPromoteGType(fn, sGType, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
dVType = WlzGreyTableType(WLZ_GREY_TAB_RAGR, dGType, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
sBgd = WlzGetBackground(sObj, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
dBgd = WlzScalarFnPixel(sBgd, fn, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
dVal.v = WlzNewValueTb(sObj, dVType, dBgd, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
dObj = WlzMakeMain(WLZ_2D_DOMAINOBJ,
sObj->domain, dVal, NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzInitGreyScan(sObj, &sIWSp, &sGWSp);
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzInitGreyScan(dObj, &dIWSp, &dGWSp);
}
if(errNum == WLZ_ERR_NONE)
{
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&sIWSp)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&dIWSp)) == WLZ_ERR_NONE))
{
int len;
WlzGreyP dGP,
sGP;
len = sIWSp.rgtpos - sIWSp.lftpos + 1;
dGP = dGWSp.u_grintptr;
sGP = sGWSp.u_grintptr;
WlzValueCopyGreyToGrey(dGP, 0, dGType, sGP, 0, sGType, len);
WlzScalarFnItv(dGP, dGType, len, fn);
}
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
}
if(dstErr)
{
*dstErr = errNum;
}
return(dObj);
}
int main(int argc, char **argv)
{
int tI,
idN,
option,
con = WLZ_0_CONNECTED,
nLo = 0,
nHi = 0,
maxSep = 1024,
nObj = 0,
ok = 1,
usage = 0;
char tC;
double tD,
mrkMass = 1.0,
rad = 0.0;
int tR[4];
WlzPixelV gV,
bV;
WlzBlobMark mrk = WLZ_BLOBMARK_CIRCLE;
WlzObject *inObj = NULL,
*outObj = NULL,
*mrkObj = NULL;
WlzObject **lObj = NULL;
FILE *fP = NULL;
char *inObjFileStr,
*outObjFileStr;
WlzErrorNum errNum = WLZ_ERR_NONE;
const char *errMsg;
static char optList[] = "c:g:G:hm:n:N:o:r:x:",
fileStrDef[] = "-";
opterr = 0;
memset(&gV, 0, sizeof(WlzPixelV));
bV.type = WLZ_GREY_UBYTE;
bV.v.ubv = 0;
gV.type = WLZ_GREY_ERROR;
inObjFileStr = fileStrDef;
outObjFileStr = fileStrDef;
while((usage == 0) && ((option = getopt(argc, argv, optList)) != -1))
{
switch(option)
{
case 'c':
if(sscanf(optarg, "%d", &tI) != 1)
{
usage = 1;
}
else
{
switch(tI)
{
case 4:
con = WLZ_4_CONNECTED;
break;
case 6:
con = WLZ_6_CONNECTED;
break;
case 8:
con = WLZ_8_CONNECTED;
break;
case 18:
con = WLZ_18_CONNECTED;
break;
case 26:
con = WLZ_26_CONNECTED;
break;
default:
usage = 1;
break;
}
}
break;
case 'g':
switch(gV.type)
{
case WLZ_GREY_UBYTE:
if((sscanf(optarg, "%d", &tI) != 1) ||
(tI < 0) || (tI > 255))
{
usage = 1;
}
else
{
gV.v.ubv = tI;
}
break;
case WLZ_GREY_SHORT:
if((sscanf(optarg, "%d", &tI) != 1) ||
(tI < SHRT_MIN) || (tI > SHRT_MAX))
{
usage = 1;
}
else
{
gV.v.shv = tI;
}
break;
case WLZ_GREY_INT:
if(sscanf(optarg, "%d", &tI) != 1)
{
usage = 1;
}
else
{
gV.v.inv = tI;
}
break;
case WLZ_GREY_FLOAT:
if((sscanf(optarg, "%lg", &tD) != 1) ||
(tD < -(FLT_MAX)) || (tD > FLT_MAX))
{
usage = 1;
}
else
{
gV.v.flv = tD;
}
break;
case WLZ_GREY_DOUBLE:
if(sscanf(optarg, "%lg", &tD) != 1)
{
usage = 1;
}
else
{
gV.v.dbv = tD;
}
break;
case WLZ_GREY_RGBA:
tR[3] = 255;
tR[0] = tR[1] = tR[2] = 0;
if((sscanf(optarg, "%d,%d,%d,%d",
&(tR[0]), &(tR[1]), &(tR[2]), &(tR[3])) == 0) ||
(tR[0] < 0) || (tR[0] > 255) ||
(tR[1] < 0) || (tR[1] > 255) ||
(tR[2] < 0) || (tR[2] > 255) ||
(tR[3] < 0) || (tR[3] > 255))
{
usage = 1;
}
else
{
WLZ_RGBA_RGBA_SET(gV.v.rgbv, tR[0], tR[1], tR[2], tR[3]);
}
break;
default:
usage = 1;
break;
}
break;
case 'G':
if(sscanf(optarg, "%c", &tC) != 1)
{
usage = 1;
}
switch(tC)
{
case 'v':
gV.type = WLZ_GREY_ERROR;
break;
case 'u':
gV.type = WLZ_GREY_UBYTE;
break;
case 's':
gV.type = WLZ_GREY_SHORT;
break;
case 'i':
gV.type = WLZ_GREY_INT;
break;
case 'f':
gV.type = WLZ_GREY_FLOAT;
break;
case 'd':
gV.type = WLZ_GREY_DOUBLE;
break;
case 'r':
gV.type = WLZ_GREY_RGBA;
break;
default:
usage = 1;
break;
}
break;
case 'm':
if((sscanf(optarg, "%d", &tI) != 1) ||
((tI != WLZ_BLOBMARK_CIRCLE) && (tI != WLZ_BLOBMARK_SQUARE)))
{
usage = 1;
}
else
{
mrk = (WlzBlobMark )tI;
}
break;
case 'n':
if((sscanf(optarg, "%d", &nLo) != 1) || (nLo < 0))
{
usage = 1;
}
break;
case 'N':
if((sscanf(optarg, "%d", &nHi) != 1) || (nHi < 0))
{
usage = 1;
}
break;
case 'o':
outObjFileStr = optarg;
break;
case 'r':
if((sscanf(optarg, "%lg", &rad) != 1) || (rad < 0.0))
{
usage = 1;
}
break;
case 'x':
if((sscanf(optarg, "%d", &maxSep) != 1) || (maxSep < 1))
{
usage = 1;
}
case 'h': /* FALLTHROUGH */
default:
usage = 1;
break;
}
}
if((usage == 0) && (nLo > nHi) && (nHi != 0))
{
usage = 1;
}
if((usage == 0) && (optind < argc))
{
if((optind + 1) != argc)
{
usage = 1;
}
else
{
inObjFileStr = *(argv + optind);
}
}
ok = (usage == 0);
/* Read input domain object. */
if(ok)
{
if((inObjFileStr == NULL) ||
(*inObjFileStr == '\0') ||
((fP = (strcmp(inObjFileStr, "-")?
fopen(inObjFileStr, "r"): stdin)) == NULL) ||
((inObj = WlzAssignObject(WlzReadObj(fP, &errNum), NULL)) == NULL) ||
(errNum != WLZ_ERR_NONE))
{
ok = 0;
}
if(fP)
{
if(strcmp(inObjFileStr, "-"))
{
(void )fclose(fP);
}
fP = NULL;
}
}
/* Check object type and connectivity. */
if(ok)
{
switch(inObj->type)
{
case WLZ_2D_DOMAINOBJ:
switch(con)
{
case WLZ_0_CONNECTED:
con = WLZ_8_CONNECTED;
break;
case WLZ_4_CONNECTED: /* FALLTHROUGH */
case WLZ_8_CONNECTED:
break;
default:
ok = 0;
errNum = WLZ_ERR_PARAM_DATA;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Connectivity for 2D must be 4 or 8 (%s).\n",
*argv, errMsg);
break;
}
break;
case WLZ_3D_DOMAINOBJ:
switch(con)
{
case WLZ_0_CONNECTED:
con = WLZ_26_CONNECTED;
break;
case WLZ_6_CONNECTED: /* FALLTHROUGH */
case WLZ_18_CONNECTED: /* FALLTHROUGH */
case WLZ_26_CONNECTED:
break;
default:
ok = 0;
errNum = WLZ_ERR_PARAM_DATA;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Connectivity for 3D must be 6, 18 or 26 (%s).\n",
*argv, errMsg);
break;
}
break;
default:
ok = 0;
errNum = WLZ_ERR_OBJECT_TYPE;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Input object must either a 2 or 3D domain object (%s).\n",
*argv, errMsg);
break;
}
}
/* Make basic marker with centre at the origin. */
if(ok)
{
double mrkRad;
if(rad > 0.5)
{
mrkRad = rad;
}
else
{
mrkRad = 127;
}
if(mrk == WLZ_BLOBMARK_SQUARE)
{
mrkObj = WlzMakeCuboidObject(inObj->type, mrkRad, mrkRad, mrkRad,
0, 0, 0, &errNum);
}
else /* mrk = WLZ_BLOBMARK_CIRCLE */
{
mrkObj = WlzMakeSphereObject(inObj->type, mrkRad, 0, 0, 0, &errNum);
}
if(mrkObj == NULL)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to create basic marker object (%s).\n",
*argv, errMsg);
}
else
{
mrkMass = WlzVolume(mrkObj, NULL);
}
}
/* Label the given domain. */
if(ok)
{
errNum = WlzLabel(inObj, &nObj, &lObj, maxSep, 1, con);
if((errNum != WLZ_ERR_NONE) || (nObj == 0))
{
ok = 0;
if(errNum == WLZ_ERR_NONE)
{
errNum = WLZ_ERR_DOMAIN_DATA;
}
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to split the given object into separate regions (%s)\n",
*argv, errMsg);
}
}
/* Work through the separate object list removing small/large objects
* according to the low and high thresholds. */
if(ok)
{
int idM;
for(idN = 0, idM = 0; idN < nObj; ++idN)
{
int vol;
vol = WlzVolume(lObj[idN], &errNum);
if(errNum == WLZ_ERR_NONE)
{
if(((nLo > 0) && (vol < nLo)) || ((nHi > 0) && (vol > nHi)))
{
(void )WlzFreeObj(lObj[idN]);
}
else
{
lObj[idM] = lObj[idN];
++idM;
}
}
}
nObj = idM;
if(nObj == 0)
{
ok = 0;
errNum = WLZ_ERR_DOMAIN_DATA;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to find and separate regions (%s)\n",
*argv, errMsg);
}
}
/* Build a marker object by adding a mark at the centre of mass of each
* separate fragment. */
if(ok)
{
WlzObject *obj0 = NULL;
idN = 0;
obj0 = WlzMakeEmpty(&errNum);
while((errNum == WLZ_ERR_NONE) && (idN < nObj))
{
double mass;
WlzDVertex3 com;
WlzObject *obj1 = NULL,
*obj2 = NULL;
WlzAffineTransform *tr = NULL;
com = WlzCentreOfMass3D(lObj[idN], 1, &mass, &errNum);
if(errNum == WLZ_ERR_NONE)
{
double s;
if(rad < 0.5)
{
double t;
t = mass / mrkMass;
if(inObj->type == WLZ_2D_DOMAINOBJ)
{
s = sqrt(t);
}
else /* inObj->type == WLZ_3D_DOMAINOBJ */
{
s = cbrt(t);
}
}
else
{
s = 1.0;
}
tr = (inObj->type == WLZ_2D_DOMAINOBJ)?
WlzAffineTransformFromPrimVal(
WLZ_TRANSFORM_2D_AFFINE, com.vtX, com.vtY, 0.0,
s, 0.0, 0.0, 0.0, 0.0, 0.0, 0, &errNum):
WlzAffineTransformFromPrimVal(
WLZ_TRANSFORM_3D_AFFINE, com.vtX, com.vtY, com.vtZ,
s, 0.0, 0.0, 0.0, 0.0, 0.0, 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
obj1 = WlzAffineTransformObj(mrkObj, tr, WLZ_INTERPOLATION_NEAREST,
&errNum);
}
if(errNum == WLZ_ERR_NONE)
{
obj2 = WlzUnion2(obj0, obj1, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
(void )WlzFreeObj(obj0);
obj0 = obj2;
obj2 = NULL;
}
(void )WlzFreeObj(obj1);
(void )WlzFreeObj(obj2);
(void )WlzFreeAffineTransform(tr);
++idN;
}
if(errNum == WLZ_ERR_NONE)
{
WlzValues val;
WlzObjectType vTT;
val.core = NULL;
if(gV.type != WLZ_GREY_ERROR)
{
vTT = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gV.type, NULL);
if(inObj->type == WLZ_2D_DOMAINOBJ)
{
val.v = WlzNewValueTb(obj0, vTT, bV, &errNum);
}
else /* inObj->type == WLZ_3D_DOMAINOBJ */
{
val.vox = WlzNewValuesVox(obj0, vTT, bV, &errNum);
}
}
if(errNum == WLZ_ERR_NONE)
{
outObj = WlzMakeMain(inObj->type, obj0->domain, val, NULL, NULL,
&errNum);
}
if((errNum == WLZ_ERR_NONE) && (gV.type != WLZ_GREY_ERROR))
{
errNum = WlzGreySetValue(outObj, gV);
}
}
}
if(ok)
{
errNum = WLZ_ERR_WRITE_EOF;
if(((fP = (strcmp(outObjFileStr, "-")?
fopen(outObjFileStr, "w"): stdout)) == NULL) ||
((errNum = WlzWriteObj(fP, outObj)) != WLZ_ERR_NONE))
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to write output object (%s).\n",
*argv, errMsg);
}
if(fP && strcmp(outObjFileStr, "-"))
{
(void )fclose(fP);
}
}
(void )WlzFreeObj(inObj);
if(lObj != NULL)
{
for(idN = 0; idN < nObj; ++idN)
{
(void )WlzFreeObj(lObj[idN]);
}
AlcFree(lObj);
}
(void )WlzFreeObj(outObj);
if(usage)
{
(void )fprintf(stderr,
"Usage: %s%sExample: %s%s",
*argv,
" [-c#] [-g#] [-G#] [-h] [-m#] [-n#] [-N#]\n"
" [-o<output object>] [-r#]] [-x#] [<input object>]\n"
"Options:\n"
" -c Connectivity: 4, 6, 8, 18 or 26 connected (default 8 for 2D\n"
" domains and 26 for 3D domains).\n"
" -g Grey value for marker. This is a single number for all except\n"
" RGBA (colour) grey values. RGBA components must be separated by\n"
" by a comma.\n"
" -G Grey value type for marker specified by letter:\n"
" v no grey values (default).\n"
" u unsigned byte grey values.\n"
" s short grey values.\n"
" i int grey values.\n"
" f int grey values.\n"
" d int grey values.\n"
" r red, green, blue, alpha grey values.\n"
" -h Help, prints usage message.\n"
" -m Marker type specified by a number:\n"
" 1 circle/sphere (default)\n"
" 2 square/cube\n"
" -n Threshold minimum area/volume of blob for a marker (default\n"
" >= 1).\n"
" -N Threshold maximum area/volume of blob for a marker. If zero\n"
" there is no upper limit. (default 0).\n"
" -o Output object file.\n"
" -r Marker radius. Attempts to keep the same area/volume if zero.\n"
" (default 0).\n"
" -x Maximum number of separate regions in the object (default 1024).\n"
"Reads a spatial domain object and replaces each spatialy separate\n"
"region with a marker placed at the centre of mass of the region.\n"
"All files are read from the standard input and written to the standard\n"
"output unless filenames are given.\n"
"If grey values are required then the grey value type must be set before\n"
"the actual grey value.\n",
*argv,
" -o out.wlz -n 4 -r 10 -G r -g 200,100,0,255 in.wlz\n"
"A spatial domain object is read from the file in.wlz and each\n"
"spatialy separate region of the domain is replaced by a circle or\n"
"sphere of radius 10 (pixels). All small regions with less than four\n"
"(pixels voxels) is ignored. The output object (with grey values set\n"
"to orange) is written to the file out.wlz.\n");
}
return(!ok);
}
/*!
* \return New Woolz domain object with gradient grey values or NULL on
* error.
* \ingroup WlzValuesFilters
* \brief Computes the magnitude of the gray values in the
* 3 given Woolz 2D domain objects.
* \param srcObj0 First object.
* \param srcObj1 Second object.
* \param srcObj2 Third object.
* \param dstErr Destination error pointer, may be null.
*/
static WlzObject *WlzGreyMagnitude2D3(WlzObject *srcObj0, WlzObject *srcObj1,
WlzObject *srcObj2,
WlzErrorNum *dstErr)
{
int idN,
itvLen,
bufSz;
double **iBufA = NULL;
WlzObject *tObj0,
*istObj = NULL,
*dstObj = NULL;
WlzObject *iObjA[3],
*tObjA[3];
WlzGreyP tGP0;
WlzGreyType dstGType = WLZ_GREY_ERROR;
WlzGreyType gTypeA[3];
WlzPixelV dstBgd;
WlzPixelV bgdA[3];
WlzValues dstVal;
WlzIntervalWSpace dstIWSp;
WlzGreyWSpace dstGWSp;
WlzIntervalWSpace iIWSpA[3];
WlzGreyWSpace iGWSpA[3];
WlzErrorNum errNum = WLZ_ERR_NONE;
*(iObjA + 0) = *(iObjA + 1) = *(iObjA + 2) = NULL;
/* Check source objects. */
if((srcObj0 == NULL) || (srcObj1 == NULL) ||(srcObj2 == NULL))
{
errNum = WLZ_ERR_OBJECT_NULL;;
}
else if((srcObj0->type != WLZ_2D_DOMAINOBJ) ||
(srcObj1->type != WLZ_2D_DOMAINOBJ) ||
(srcObj2->type != WLZ_2D_DOMAINOBJ))
{
errNum = WLZ_ERR_OBJECT_TYPE;
}
else if((srcObj0->domain.core == NULL) ||
(srcObj1->domain.core == NULL) ||
(srcObj2->domain.core == NULL))
{
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if((srcObj0->values.core == NULL) ||
(srcObj1->values.core == NULL) ||
(srcObj2->values.core == NULL))
{
errNum = WLZ_ERR_VALUES_NULL;
}
/* Compute the intersection of the source objects. */
if(errNum == WLZ_ERR_NONE)
{
*(tObjA + 0) = srcObj0;
*(tObjA + 1) = srcObj1;
*(tObjA + 2) = srcObj2;
istObj = WlzIntersectN(3, tObjA, 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
*(iObjA + 0) = WlzMakeMain(WLZ_2D_DOMAINOBJ,
istObj->domain, srcObj0->values,
NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
*(iObjA + 1) = WlzMakeMain(WLZ_2D_DOMAINOBJ,
istObj->domain, srcObj1->values,
NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
*(iObjA + 2) = WlzMakeMain(WLZ_2D_DOMAINOBJ,
istObj->domain, srcObj2->values,
NULL, NULL, &errNum);
}
/* Get background value and grey types */
idN = 0;
while((errNum == WLZ_ERR_NONE) && (idN < 3))
{
tObj0 = *(iObjA + idN);
*(gTypeA + idN) = WlzGreyTableTypeToGreyType(tObj0->values.core->type,
&errNum);
if(errNum == WLZ_ERR_NONE)
{
*(bgdA + idN) = WlzGetBackground(tObj0, &errNum);
}
++idN;
}
/* Promote grey types. */
if(errNum == WLZ_ERR_NONE)
{
if((*(gTypeA + 0) == WLZ_GREY_DOUBLE) ||
(*(gTypeA + 1) == WLZ_GREY_DOUBLE) ||
(*(gTypeA + 2) == WLZ_GREY_DOUBLE))
{
dstGType = WLZ_GREY_DOUBLE;
}
else if((*(gTypeA + 0) == WLZ_GREY_FLOAT) ||
(*(gTypeA + 1) == WLZ_GREY_FLOAT) ||
(*(gTypeA + 2) == WLZ_GREY_FLOAT))
{
dstGType = WLZ_GREY_FLOAT;
}
else if((*(gTypeA + 0) == WLZ_GREY_INT) ||
(*(gTypeA + 1) == WLZ_GREY_INT) ||
(*(gTypeA + 2) == WLZ_GREY_INT))
{
dstGType = WLZ_GREY_INT;
}
else if((*(gTypeA + 0) == WLZ_GREY_SHORT) ||
(*(gTypeA + 1) == WLZ_GREY_SHORT) ||
(*(gTypeA + 2) == WLZ_GREY_SHORT))
{
dstGType = WLZ_GREY_SHORT;
}
else if((*(gTypeA + 0) == WLZ_GREY_UBYTE) ||
(*(gTypeA + 1) == WLZ_GREY_UBYTE) ||
(*(gTypeA + 2) == WLZ_GREY_UBYTE))
{
dstGType = WLZ_GREY_SHORT;
}
else
{
/* RGBA to be done RAB */
errNum = WLZ_ERR_GREY_TYPE;
}
}
/* Make destination object with intersection domain and new values. */
if(errNum == WLZ_ERR_NONE)
{
(void )WlzValueConvertPixel(&dstBgd, *(bgdA + 0), dstGType);
dstVal.v = WlzNewValueTb(*(iObjA + 0),
WlzGreyValueTableType(0, WLZ_GREY_TAB_RAGR,
dstGType, NULL),
dstBgd, &errNum);
if(errNum == WLZ_ERR_NONE)
{
dstObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, istObj->domain, dstVal,
NULL, NULL, &errNum);
}
}
if(istObj)
{
WlzFreeObj(istObj);
}
/* Make buffers. */
if(errNum == WLZ_ERR_NONE)
{
bufSz = dstObj->domain.i->lastkl - dstObj->domain.i->kol1 + 1;
if(AlcDouble2Malloc(&iBufA, 3, bufSz) != ALC_ER_NONE)
{
errNum = WLZ_ERR_MEM_ALLOC;
}
}
/* Scan through the objects computing the magnitude. */
if(errNum == WLZ_ERR_NONE)
{
idN = 0;
while((errNum == WLZ_ERR_NONE) && (idN < 3))
{
errNum = WlzInitGreyScan(*(iObjA + idN), iIWSpA + idN, iGWSpA + idN);
++idN;
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzInitGreyScan(dstObj, &dstIWSp, &dstGWSp);
}
while((errNum == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(iIWSpA + 0)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(iIWSpA + 1)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(iIWSpA + 2)) == WLZ_ERR_NONE) &&
((errNum = WlzNextGreyInterval(&dstIWSp)) == WLZ_ERR_NONE))
{
itvLen = dstIWSp.rgtpos - dstIWSp.lftpos + 1;
/* Copy intervals to double buffers. */
idN = 0;
while(idN < 3)
{
tGP0.dbp = *(iBufA + idN);
WlzValueCopyGreyToGrey(tGP0, 0,
WLZ_GREY_DOUBLE,
(iGWSpA + idN)->u_grintptr, 0,
(iGWSpA + idN)->pixeltype,
itvLen);
++idN;
}
/* Compute magnitude. */
WlzBufMagD3(*(iBufA + 0), *(iBufA + 1), *(iBufA + 2), itvLen);
/* Clamp into destination interval. */
tGP0.dbp = *(iBufA + 0);
WlzValueClampGreyIntoGrey(dstGWSp.u_grintptr, 0, dstGWSp.pixeltype,
tGP0, 0, WLZ_GREY_DOUBLE,
itvLen);
}
if(errNum == WLZ_ERR_EOO)
{
errNum = WLZ_ERR_NONE;
}
}
/* Free intersection objects. */
idN = 0;
while(idN < 3)
{
if(iObjA[idN])
{
WlzFreeObj(iObjA[idN]);
}
++idN;
}
/* Free buffers. */
if(iBufA)
{
Alc2Free((void **)iBufA);
}
/* Tidy up on error. */
if(dstObj && (errNum != WLZ_ERR_NONE))
{
WlzFreeObj(dstObj);
dstObj = NULL;
}
/* Pass back error status. */
if(dstErr)
{
*dstErr = errNum;
}
return(dstObj);
}
