/*!
* \ingroup WlzBoundary
* \brief Return a domain object corresponding to the input boundary
object.
*
* \return Domain object corresponding to the input boundary, NULL on error.
* \param boundary Input boundary object.
* \param fillMode Fill mode for the individual polyline boundaries.
If the input object is a genuine boundary object then there will be no
self-intersecting polylines and <tt> fillMode = WLZ_SIMPLE_FILL </tt>
is appropriate. See WlzPolyToObj().
* \param dstErr Error return
* \par Source:
* WlzBoundToObj.c
*/
WlzObject *WlzBoundaryToObj(
WlzObject *boundary,
WlzPolyFillMode fillMode,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL, *tmpObj;
WlzDomain domain, *domains, *bnddmns;
WlzValues values;
int p;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check object */
if( boundary == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( boundary->type ){
case WLZ_3D_DOMAINOBJ:
/* check plane domain */
if( boundary->domain.p == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else {
switch( boundary->domain.p->type ){
case WLZ_PLANEDOMAIN_BOUNDLIST:
if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
boundary->domain.p->plane1,
boundary->domain.p->lastpl,
boundary->domain.p->line1,
boundary->domain.p->lastln,
boundary->domain.p->kol1,
boundary->domain.p->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = boundary->domain.p->voxel_size[0];
domain.p->voxel_size[1] = boundary->domain.p->voxel_size[1];
domain.p->voxel_size[2] = boundary->domain.p->voxel_size[2];
domains = domain.p->domains;
bnddmns = boundary->domain.p->domains;
for(p=domain.p->plane1; p <= domain.p->lastpl;
p++, domains++, bnddmns++){
if( (*bnddmns).poly ){
if((tmpObj = WlzBoundToObj((*bnddmns).b, fillMode,
&errNum)) != NULL){
*domains = WlzAssignDomain(tmpObj->domain, NULL);
WlzFreeObj(tmpObj);
}
else {
WlzFreePlaneDomain(domain.p);
domain.p = NULL;
break;
}
}
}
if( domain.p ){
values.core = NULL;
if( (rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum)) == NULL ){
WlzFreePlaneDomain(domain.p);
}
}
}
break;
case WLZ_EMPTY_DOMAIN:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
}
break;
case WLZ_BOUNDLIST:
return WlzBoundToObj(boundary->domain.b, fillMode, dstErr);
case WLZ_TRANS_OBJ:
if((values.obj = WlzBoundaryToObj(boundary->values.obj, fillMode,
&errNum)) != NULL){
return WlzMakeMain(WLZ_TRANS_OBJ, boundary->domain, values,
NULL, NULL, dstErr);
}
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
int main(int argc, char *argv[])
{
int ok,
bnd = 0,
con,
option,
usage = 0;
char *inFileStr,
*forFileStr,
*refFileStr,
*outFileStr;
double dParam = 10.0;
FILE *fP = NULL;
WlzObject *tObj0,
*tObj1,
*forObj = NULL,
*refObj = NULL,
*dstObj = NULL;
WlzDistanceType dFn;
WlzErrorNum errNum = WLZ_ERR_NONE;
const char *errMsgStr;
static char optList[] = "bhd:f:p:o:";
const char fileStrDef[] = "-";
const WlzConnectType defDFn = WLZ_OCTAGONAL_DISTANCE;
/* Parse the argument list and check for input files. */
opterr = 0;
inFileStr = (char *)fileStrDef;
forFileStr = (char *)fileStrDef;
outFileStr = (char *)fileStrDef;
dFn = defDFn;
while((option = getopt(argc, argv, optList)) != EOF)
{
switch(option)
{
case 'b':
bnd = 1;
break;
case 'd':
if(sscanf(optarg, "%d", &con) != 1)
{
usage = 1;
}
else
{
switch(con)
{
case 0:
dFn = WLZ_EUCLIDEAN_DISTANCE;
break;
case 1:
dFn = WLZ_OCTAGONAL_DISTANCE;
break;
case 2:
dFn = WLZ_APX_EUCLIDEAN_DISTANCE;
break;
case 4:
dFn = WLZ_4_DISTANCE;
break;
case 6:
dFn = WLZ_6_DISTANCE;
break;
case 8:
dFn = WLZ_8_DISTANCE;
break;
case 18:
dFn = WLZ_18_DISTANCE;
break;
case 26:
dFn = WLZ_26_DISTANCE;
break;
default:
usage = 1;
break;
}
}
break;
case 'f':
forFileStr = optarg;
break;
case 'p':
if(sscanf(optarg, "%lg", &dParam) != 1)
{
usage = 1;
}
break;
case 'o':
outFileStr = optarg;
break;
case 'h':
default:
usage = 1;
break;
}
}
ok = !usage;
if(ok && (optind < argc))
{
if((optind + 1) != argc)
{
usage = 1;
ok = 0;
}
else
{
refFileStr = argv[optind];
}
}
/* Read the reference object. */
if(ok)
{
if((refFileStr == NULL) ||
(*refFileStr == '\0') ||
((fP = (strcmp(refFileStr, "-")?
fopen(refFileStr, "r"): stdin)) == NULL) ||
((refObj = WlzAssignObject(WlzReadObj(fP, &errNum), NULL)) == NULL))
{
ok = 0;
(void )fprintf(stderr,
"%s: Failed to read reference object from file %s.\n",
argv[0], refFileStr);
}
if(fP && strcmp(refFileStr, "-"))
{
(void )fclose(fP); fP = NULL;
}
}
/* Read the foreground object. */
if(ok)
{
if((forFileStr == NULL) ||
(*forFileStr == '\0') ||
((fP = (strcmp(forFileStr, "-")?
fopen(forFileStr, "r"): stdin)) == NULL) ||
((forObj = WlzAssignObject(WlzReadObj(fP, &errNum), NULL)) == NULL))
{
ok = 0;
(void )fprintf(stderr,
"%s: Failed to read foreground object from file %s.\n",
argv[0], forFileStr);
}
if(fP && strcmp(forFileStr, "-"))
{
(void )fclose(fP); fP = NULL;
}
}
/* Check object types and parse the promote the default distance function
* if required. */
if(ok)
{
if(refObj->type != forObj->type)
{
ok = 0;
(void )fprintf(stderr,
"%s: Foreground and reference object types differ.\n",
argv[0]);
}
}
if((errNum == WLZ_ERR_NONE) && bnd)
{
tObj0 = tObj1 = NULL;
tObj0 = WlzObjToBoundary(refObj, 1, &errNum);
if(errNum == WLZ_ERR_NONE)
{
tObj1 = WlzBoundaryToObj(tObj0, WLZ_VERTEX_FILL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
(void )WlzFreeObj(refObj);
refObj = tObj1;
tObj1 = NULL;
}
(void )WlzFreeObj(tObj0);
(void )WlzFreeObj(tObj1);
}
/* Compute the distance transform object. */
if(ok)
{
dstObj = WlzAssignObject(
WlzDistanceTransform(forObj, refObj, dFn, dParam, &errNum), NULL);
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsgStr);
(void )fprintf(stderr,
"%s: Failed to compute distance object, %s.\n",
argv[0], errMsgStr);
}
}
/* Output the distance transform object. */
if(ok)
{
if((fP = (strcmp(outFileStr, "-")?
fopen(outFileStr, "w"): stdout)) == NULL)
{
ok = 0;
(void )fprintf(stderr,
"%s: Failed to open output file %s.\n",
argv[0], outFileStr);
}
}
if(ok)
{
errNum = WlzWriteObj(fP, dstObj);
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsgStr);
(void )fprintf(stderr,
"%s: Failed to write output object, %s.\n",
argv[0], errMsgStr);
}
}
(void )WlzFreeObj(forObj);
(void )WlzFreeObj(refObj);
(void )WlzFreeObj(dstObj);
if(usage)
{
(void )fprintf(stderr,
"Usage: %s [-b] [-d#] [-f#] [-p#] [-o#] [-h] [<Reference input file>]\n"
"Computes a distance transform object which has the domain of the\n"
"foreground object and values which are the distance from the reference\n"
"object.\n"
"Options are:\n"
" -b Use the boundary of the reference object.\n"
" -d Distance function:\n"
" 0: Euclidean (2D and 3D, unimplemented)\n"
" 1: octagonal (2D and 3D) - default\n"
" 2: approximate Euclidean (2D and 3D)\n"
" 4: 4-connected (2D)\n"
" 8: 8-connected (2D)\n"
" 6: 6-connected (3D)\n"
" 18: 18-connected (3D)\n"
" 26: 26-connected (3D)\n"
" -f The foreground object file.\n"
" -p Distance function parameter, which is curently only used for\n"
" approximate Euclidean distance transforms. The value should\n"
" be >= 1, with larger values giving greater accuracy at the\n"
" cost of increased time. Default value - 10.0.\n"
" -o Output object file.\n"
" -h Help - prints this usage message\n",
argv[0]);
}
return(!ok);
}
