Ilwis::OperationImplementation::State CreateSimpelRasterCoverage::prepare(ExecutionContext *ctx,const SymbolTable&){
IRasterCoverage inputRaster;
if ( _expression.parm(0).valuetype() == itRASTER){
if(!inputRaster.prepare(_expression.input<QString>(0))){
kernel()->issues()->log(TR("Invalid raster used to create new raster:") + _expression.input<QString>(0));
return sPREPAREFAILED;
}
_outputRaster = OperationHelperRaster::initialize(inputRaster,itRASTER,itRASTERSIZE|itDOMAIN|itCOORDSYSTEM|itGEOREF);
return sPREPARED;
}
QString grf = _expression.input<QString>(0);
if ( ! _grf.prepare(grf)){
kernel()->issues()->log(QString(TR("%1 is and invalid georeference")).arg(grf));
return sPREPAREFAILED;
}
_empty = _expression.input<bool>(1);
_domain.prepare("code=domain:value");
_stackDomain = IDomain("count");
if (!_empty){
_stackValueStrings = {"1"};
_stackValueNumbers = {1};
}
_outputRaster.prepare();
_outputRaster->georeference(_grf);
_outputRaster->setDataDefintions(_domain, _stackValueNumbers , _stackDomain);
return sPREPARED;
}
DataDefinition IfOperation::findParameterDataDef(const OperationExpression &expr, int index) {
const Parameter& parm = expr.parm(index);
DataDefinition def;
QString parmvalue = parm.value().toLower();
quint64 gcid = mastercatalog()->name2id(parmvalue, itRASTER);
if ( gcid != i64UNDEF) {
IRasterCoverage cov;
if(cov.prepare(gcid)) {
def = cov->datadef();
_coverages[index - 1] = cov.get<Coverage>();
}
} else {
bool ok;
_number[index - 1] =parmvalue.toDouble(&ok);
if ( ok){
def.domain().prepare("value");
} else {
std::vector<QString> bools = {"true","false","yes","no","?"};
auto iter = std::find(bools.begin(), bools.end(), parmvalue.toLower());
if ( iter != bools.end()) {
int v = 0;
if ( parmvalue == "?" )
v= 2;
else if ( parmvalue == "yes" || parmvalue == "true")
v = 1;
_number[index - 1] = v;
IDomain dm;
dm.prepare("boolean");
def.domain(dm);
}
}
}
return def;
}
DataDefinition IfOperation::findParameterDataDef(const OperationExpression &expr, int index) {
const Parameter& parm = expr.parm(index);
DataDefinition def;
QString parmvalue = parm.value();
IlwisTypes ptype = parm.valuetype();
if (hasType(ptype,itRASTER)) {
IRasterCoverage cov;
if (cov.prepare(parmvalue)) {
def = cov->datadef();
_coverages[index - 1] = cov.as<Coverage>();
}
} else {
bool ok;
_number[index - 1] = parmvalue.toDouble(&ok);
if ( ok){
IDomain dom("code=domain:value");
def.domain(dom);
} else {
std::vector<QString> bools = {"true","false","yes","no","?"};
auto iter = std::find(bools.begin(), bools.end(), parmvalue.toLower());
if ( iter != bools.end()) {
int v = 0;
if ( parmvalue == "?" )
v= 2;
else if ( parmvalue == "yes" || parmvalue == "true")
v = 1;
_number[index - 1] = v;
IDomain dm;
dm.prepare("boolean");
def.domain(dm);
}
}
}
return def;
}
OperationImplementation::State MapCalc::prepare(ExecutionContext *ctx,const SymbolTable &st) {
OperationImplementation::prepare(ctx,st);
QString expr = _expression.input<QString>(0);
RasterStackDefinition stackdef;
for(int parmIndex = 1 ; parmIndex < _expression.parameterCount(); ++parmIndex){
Parameter parm = _expression.parm(parmIndex);
if ( hasType(parm.valuetype(), itRASTER)){
QString url = parm.value();
IRasterCoverage raster;
if(!raster.prepare(url)){
return sPREPAREFAILED;
}
if ( stackdef.isValid()){
if(!stackdef.checkStackDefintion(raster->stackDefinition())){
kernel()->issues()->log(TR("Incompatible stack definition for ") +raster->name() ) ;
return sPREPAREFAILED;
}
}else if ( raster->stackDefinition().domain()->code().indexOf("count") == -1)
stackdef = raster->stackDefinition();
_inputRasters[parmIndex] = PixelIterator(raster);
}else if ( hasType(parm.valuetype(), itNUMBER)){
bool ok;
double v = parm.value().toDouble(&ok);
if (!ok){
return sPREPAREFAILED;
}
_inputNumbers[parmIndex] = v;
}
}
OperationHelperRaster helper;
helper.initialize((*_inputRasters.begin()).second.raster(), _outputRaster, itRASTERSIZE | itENVELOPE | itCOORDSYSTEM | itGEOREF);
if ( stackdef.isValid()){
_outputRaster->stackDefinitionRef() = stackdef;
}
IDomain outputDomain;
try {
outputDomain = linearize(shuntingYard(expr));
if( !outputDomain.isValid())
return sPREPAREFAILED;
} catch(ErrorObject& err){
return sPREPAREFAILED;
}
_outputRaster->datadefRef().domain(outputDomain);
for(quint32 i = 0; i < _outputRaster->size().zsize(); ++i){
QString index = _outputRaster->stackDefinition().index(i);
_outputRaster->setBandDefinition(index,DataDefinition(outputDomain));
}
initialize(_outputRaster->size().linearSize());
return sPREPARED;
}
Ilwis::OperationImplementation::State RasterClassification::prepare(ExecutionContext *, const SymbolTable &sym){
QString rasterSetName = _expression.parm(0).value();
IRasterCoverage rcSet;
if (!rcSet.prepare(rasterSetName)) {
ERROR2(ERR_COULD_NOT_LOAD_2,rasterSetName,"");
return sPREPAREFAILED;
}
QString domain = _expression.parm(1).value();
IThematicDomain themes;
if ( !themes.prepare(domain)){
ERROR2(ERR_COULD_NOT_LOAD_2,domain,"");
return sPREPAREFAILED;
}
QString trainingsRaster = _expression.parm(2).value();
IRasterCoverage rcTraining;
if (!rcTraining.prepare(trainingsRaster, itRASTER)) {
ERROR2(ERR_COULD_NOT_LOAD_2,trainingsRaster,"");
return sPREPAREFAILED;
}
_sampleSet = SampleSet(rcSet, themes, rcTraining);
_sampleSet.prepare();
QString outputName = _expression.parm(0,false).value();
OperationHelperRaster::initialize(_sampleSet.sampleRasterSet(), _outputRaster, itCOORDSYSTEM | itGEODETICDATUM | itGEOREF | itRASTERSIZE);
if ( !_outputRaster.isValid()) {
ERROR1(ERR_NO_INITIALIZED_1, "output rastercoverage");
return sPREPAREFAILED;
}
_outputRaster->datadefRef().domain(_sampleSet.thematicDomain());
_outputRaster->size(_sampleSet.sampleRasterSet()->size().twod());
if ( outputName!= sUNDEF)
_outputRaster->name(outputName);
return sPREPARED;
}
BoundingBox OperationHelperRaster::initialize(const IRasterCoverage &inputRaster, IRasterCoverage &outputRaster, quint64 what)
{
Resource resource(itRASTER);
Size<> sz = inputRaster->size();
BoundingBox box(sz);
if ( what & itRASTERSIZE) {
resource.addProperty("size", IVARIANT(sz.toString()));
}
if ( what & itENVELOPE) {
if ( box.isNull() || !box.isValid()) {
sz = inputRaster->size();
box = BoundingBox(sz);
}
Envelope bounds = inputRaster->georeference()->pixel2Coord(box);
resource.addProperty("envelope", IVARIANT(bounds.toString()));
}
if ( what & itCOORDSYSTEM) {
resource.addProperty("coordinatesystem", IVARIANT(inputRaster->coordinateSystem()->id()));
}
if ( what & itGEOREF) {
if ( box.isNull() || !box.isValid()) {
sz = inputRaster->size();
box = BoundingBox(sz);
}
if ( sz.xsize() == box.xlength() && sz.ysize() == box.ylength())
resource.addProperty("georeference", IVARIANT(inputRaster->georeference()->id()));
}
if ( what & itDOMAIN) {
resource.addProperty("domain", IVARIANT(inputRaster->datadef().domain<>()->id()));
}
resource.prepare();
outputRaster.prepare(resource);
if ( what & itTABLE) {
if ( inputRaster->attributeTable().isValid()) {
if ( inputRaster->datadef().domain<>() == outputRaster->datadef().domain<>()) {
if ( outputRaster.isValid())
outputRaster->setAttributes(inputRaster->attributeTable());
}
}
}
if ( what & itDOMAIN){
for(quint32 i = 0; i < outputRaster->size().zsize(); ++i){
QString index = outputRaster->stackDefinition().index(i);
outputRaster->setBandDefinition(index,DataDefinition(outputRaster->datadef().domain()));
}
}
return box;
}
bool PinDataSource::setStackDomain(const QString& id) {
IRasterCoverage raster;
raster.prepare(_objid);
bool ok;
_actives.clear();
quint64 oid = id.toULongLong(&ok);
if (!ok) {
kernel()->issues()->log(TR("No valid object id used: ") + id);
return false;
}
RasterStackDefinition& stack = raster->stackDefinitionRef();
IDomain dom;
if (dom.prepare(oid) && dom->ilwisType() == itITEMDOMAIN) {
_stackDomain = dom;
IItemDomain itemdom = dom.as< ItemDomain<DomainItem>>();
if (itemdom->count() == raster->size().zsize()) {
std::vector<QString> items;
for (auto item : itemdom) {
items.push_back(item->name());
}
stack.setSubDefinition(itemdom, items);
}
else {
kernel()->issues()->log(TR("Item domain must have same size as tjhe number of bands in the container"));
return false;
}
}
for (quint32 i = 0; i < stack.count(); ++i) {
QString name = QString::number(i + 1); // stack.index(i+1);
QVariantMap data;
data["name"] = name;
data["active"] = true;
if (_stackDomain->valueType() != itNUMERICITEM) {
data["minvalue"] = "?";
data["maxvalue"] = "?";
}
else {
IIntervalDomain idomain = _stackDomain.as<IntervalDomain>();
if (idomain->count() == stack.count()) {
auto item = idomain->item(i)->as<Interval>();
data["name"] = item->name();
auto range = item->range().as<NumericRange>();
data["minvalue"] = QString::number(range->min());
data["maxvalue"] = QString::number(range->max());
}
}
_actives.push_back(data);
}
return true;
}
PinDataSource::PinDataSource(quint64 objid, QObject *parent) : QObject(parent) {
IRasterCoverage raster;
raster.prepare(objid);
if (!raster.isValid())
return;
_objid = objid;
_stackDomain = raster->stackDefinition().domain();
CrosssectionTool *tool = static_cast<CrosssectionTool *>(parent);
IRasterCoverage rasterPanel = tool->coverage().as<RasterCoverage>();
if (!rasterPanel.isValid()) {
throw ErrorObject(TR("Crossection tool only works for raster coverages"));
}
if (!raster->georeference()->isCompatible(rasterPanel->georeference())) {
throw ErrorObject(TR("Rasters must have compatible georeferences"));
}
setStackDomain( QString::number(_stackDomain->id()));
}
