ImageProcessorDescription.cpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include<ImLib3D/ImageProcessorDescription.hpp>
#include<ImLib3D/Image3D.hpp>


bool 
ImageArgument::IsValid(const string &strArg,string &message)
{
    if(IsInput())
    {
        string imType=Container3D_ReadImageType(strArg);
        if(imType=="NOT IMLIB3D IMAGE"){message="invalid image:\""+strArg+"\"";return false;}
    }
    else
    {
        if(strArg==""){message="empty result filename";return false;}
    }
    return true;
}

ImProcStringArgument *
ImProcStringArgument::Create(XIPD::Argument &argument,ImageProcessorsDescription &improcs)
{
    string type=argument.type;
    if(type=="bool"    ){return new ImProcStringArgument(argument,improcs);}
    if(type=="string"  ){return new ImProcStringArgument(argument,improcs);}
    if(type=="int"     ){return new ImProcStringArgument(argument,improcs);}
    if(type=="float"   ){return new ImProcStringArgument(argument,improcs);}

    if(type=="ImageType"){return new ImageArgument(argument,improcs);}
//  if(type=="StructureElement"   ){return new ImProcStringArgument(argument,improcs);}
    // FIXME this should find a smarter, reliable way of knowing
    // if this is an image argument (maybe l this argument stuff 
    // is not in its right place, maybe this should be done by applications
    // needs
    vector<string> imageTypes;
    imageTypes.push_back("BitImage3D<byte,1,byte>");
    imageTypes.push_back("BitImage3D<byte,2,byte>");
    imageTypes.push_back("Image3Dd");
    imageTypes.push_back("Image3Df");
    imageTypes.push_back("Image3Dlinear<complex<double> >");
    imageTypes.push_back("Image3Dlinear<complex<float> >");
    imageTypes.push_back("Image3Dreal<int>");
    imageTypes.push_back("Image3Dreal<short int>");
    imageTypes.push_back("Mask3D");
    imageTypes.push_back("Image3Dlinear<Vect3Df>");
    imageTypes.push_back("Image3Dlinear<Vect3D<float, float> >");
    imageTypes.push_back("Field3Df");
 
    if(find(imageTypes.begin(),imageTypes.end(),type)!=imageTypes.end())
    {
        return new ImageArgument(argument,improcs);
    }

    if(type=="ImageTypeName") {return new ImProcStringArgument(argument,improcs);}

    // types with descriptions
    XIPD::ArgumentType *typeDesc=improcs.GetArgumentType(type,false);
    if(typeDesc && typeDesc->type=="list"){return new ListArgument(argument,improcs);}

//  printf("unknown argument description type:\"%s\" ... using default\n",type.c_str());
    return new ImProcStringArgument(argument,improcs);
}

vector<string> 
ImageProcessorDescription::BuildCmdLine(const vector<string> &args0,bool stripTrailingSpaces)
{
    vector<string> res;
    res.push_back(name);
    for(uint i=0;i<args.size();i++)
    {
        string str=args0[i];
        if(str.size()!=0)
        {
            if(stripTrailingSpaces)
            {
                int j;
                for(j=str.size()-1;j>=0 && isspace(str[j]);j--);
                str=str.substr(0,j+1);
            }
            if(str[0]=='-' && str.size()>1 && str[1]=='-')
            {ThrowError("ImageProcessorDescription::BuildCmdLine arg starts with \"--\", could be mistaken with switch");} 
        }
        res.push_back(args[i]->FullSwitch()+"=\""+str+"\"");
    }
    return res;
}

vector<string> 
ImageProcessorDescription::ParseCmdLine(vector<string> cmdline)
{
    vector<string> resArgs(size());

    // **** remove full-switch'ed args (must be quoted if spaces)
    for(uint i=0;i<cmdline.size();i++)
    {
        string arg=cmdline[i];
        if(arg.substr(0,2)=="--")
        {
            uint eq=arg.find('=');
            if(eq==string::npos){ThrowError("no argument for switch \"%s\"",arg);}
            resArgs[FindFullSwitch(arg.substr(0,eq))]=arg.substr(eq+1);
            cmdline.erase(cmdline.begin()+i);
            i--;
            continue;
        }
    }
    // **** remove short-switch'ed args
    // **** fit remaining args      
    int carg=1; // current index in initial cmdline args (ignore 0->procName)
    for(uint i=0;i<size();i++)
    {
        if(resArgs[i]!=""){continue;}// arg has already been processed
        ImProcStringArgument *arg=args[i];
        if(arg->IsOptional() && carg>=(int)cmdline.size())
        {break;}// no more optional args on command line

        try
        {
            // find number of expected elements for this argument
            int cmdLineNumber=1;
            if(arg->TypeDescritption())
            {
                cmdLineNumber=LongInt(arg->TypeDescritption()->cmdLineNumber);
            }
            if(cmdLineNumber==0){cmdLineNumber=1;}
            if((carg+cmdLineNumber)>(int)cmdline.size()){ThrowError("not enough args\n");}
            // put all  elements for this argument in res string
            for(int j=0;j<cmdLineNumber;j++){resArgs[i]+=(j>0 ? " " : "")+cmdline[carg++];}
        }catch(std::exception& __fail)
        {ThrowError("problem in parsing argument \"%s\"",arg->Name());}
    }
    if(carg!=(int)cmdline.size()){ThrowError("too many commandline args");}
    return resArgs;
}

void  
ImageProcessorDescription::ValidateArguments(const vector<string> &resArgs)
{
    // validate arguments
    for(uint i=0;i<size();i++)
    {
        string message;
        if(args[i]->IsOptional() && resArgs[i]==""){continue;}
        if(!args[i]->IsValid(resArgs[i],message))
        {ThrowError("Invalid argument \"%s\":%s",args[i]->Name(),message);}
    }
    for(uint i=0;i<resArgs.size();i++)
    {
        printf("validated final arg:%d:\"%s\"\n",i,resArgs[i].c_str());
    }
}


int 
ImageProcessorDescription::ProcTemplateTypeNamePos()
{
    XIPD::ImageProcessor *proc=improcs.GetImageProcessor(name);
    if(proc->type=="standard templated" && proc->templateGroup==""){return 0;}
    if(proc->type=="standard templated" && proc->templateGroup!=""){return LongInt(proc->templateGroup);}
    return -1;
}

string 
ImageProcessorDescription::ProcTemplateTypeName(vector<string> resArgs)
{
    string typeName;
    XIPD::ImageProcessor *proc=improcs.GetImageProcessor(name);
    if(proc->type=="standard templated" )
    {
        typeName=Container3D_ReadImageType(resArgs[0]);
    }
//  if(proc->type=="standard templated" && proc->templateGroup==""){typeName=Container3D_ReadImageType(resArgs[1]);}
//  if(proc->type=="standard templated" && proc->templateGroup!=""){typeName=resArgs[LongInt(proc->templateGroup)];}
    return typeName;
}


void 
ImageProcessorDescription::PrintDoxyDoc(const string& type)
{
    if(type=="class head")
    {
        improcs.Print(shortDescription,4,80);
        improcs.Print(longDescription,8,76);            
        vector<string> argnames;
        for(uint i=0;i<args.size();i++){argnames.push_back(args[i]->Name().c_str());}
        improcs.Pad(argnames);
        printf("     <UL>Args:\n");
        for(uint i=0;i<args.size();i++)
        {
            printf("      <LI>%s  type:%s\n",
                   argnames[i].c_str(),
                   args[i]->Type().c_str() );
                
        }
        printf("     </UL>\n");
    }
}

void 
ImageProcessorDescription::PrintHelp()
{
    printf("%s (%s)\n",name.c_str(),parent.c_str());
    improcs.Print(shortDescription,4,80);
    improcs.Print(longDescription,8,76);
//          printf("%s\n\n",GetContent(name,"ShortDescription").c_str());
//          printf("%s\n",GetContent(name,"LongDescription").c_str());
    vector<string> argnames;
    for(uint i=0;i<args.size();i++)
    {
        string name=args[i]->Name().c_str();
        if(args[i]->IsOptional()){name="[opt] "+name;}
        argnames.push_back(name);
    }
    improcs.Pad(argnames);
    printf("    Args:\n");
    for(uint i=0;i<args.size();i++)
    {
        printf("      %s  type:%s\n",
               argnames[i].c_str(),
               args[i]->Type().c_str() );
                   
    }
}

---