void otb::Wrapper::ObjectsRadiometricStatistics::DoExecute()
{
VectorImageType::Pointer referenceImage = GetParameterImage("im");
otb::ogr::DataSource::Pointer ogrDS;
ogrDS = otb::ogr::DataSource::New(GetParameterString("in"), otb::ogr::DataSource::Modes::Update_LayerUpdate);
m_OGRDataSourceRendering = OGRDataSourceToMapFilterType::New();
m_OGRDataSourceRendering->AddOGRDataSource(ogrDS);
m_OGRDataSourceRendering->SetOutputSize(referenceImage->GetLargestPossibleRegion().GetSize());
m_OGRDataSourceRendering->SetOutputOrigin(referenceImage->GetOrigin());
m_OGRDataSourceRendering->SetOutputSpacing(referenceImage->GetSpacing());
m_OGRDataSourceRendering->SetOutputProjectionRef(referenceImage->GetProjectionRef());
// m_OGRDataSourceRendering->SetOutputParametersFromImage(referenceImage); // A tester
m_OGRDataSourceRendering->SetBackgroundValue(GetParameterInt("background"));
m_OGRDataSourceRendering->SetBurnAttributeMode(true);
m_OGRDataSourceRendering->SetBurnAttribute(GetParameterString("field"));
// Write label image from OGR
/*
WriterType::Pointer writer = WriterType::New();
writer->SetInput(m_OGRDataSourceRendering->GetOutput());
writer->SetFileName("label_image.tif");
writer->Update();
*/
// Label image from OGR to statistics label map
ConverterStatisticsType::Pointer converterStats = ConverterStatisticsType::New();
converterStats->SetInput(m_OGRDataSourceRendering->GetOutput());
converterStats->SetBackgroundValue(GetParameterInt("background"));
converterStats->Update();
// Prepare channel extraction
ExtractROIFilterType::Pointer m_ExtractROIFilter = ExtractROIFilterType::New();
m_ExtractROIFilter->SetInput(referenceImage);
// Update dataset with new fields
otb::ogr::Layer layer = ogrDS->GetLayerChecked(0);
OGRFieldDefn fieldNbPixels("NbPixels", OFTInteger);
layer.CreateField(fieldNbPixels, true);
OGRFieldDefn fieldFlatness("Flat", OFTReal);
layer.CreateField(fieldFlatness, true);
OGRFieldDefn fieldRoundness("Round", OFTReal);
layer.CreateField(fieldRoundness, true);
OGRFieldDefn fieldElongation("Elong", OFTReal);
layer.CreateField(fieldElongation, true);
OGRFieldDefn fieldPerimeter("Perim", OFTReal);
layer.CreateField(fieldPerimeter, true);
for(unsigned int i = 0; i < referenceImage->GetNumberOfComponentsPerPixel(); i++)
{
std::ostringstream fieldoss;
fieldoss<<"meanB"<<i+1;
OGRFieldDefn field(fieldoss.str().c_str(), OFTReal);
layer.CreateField(field, true);
}
for(unsigned int i = 0; i < referenceImage->GetNumberOfComponentsPerPixel(); i++)
{
std::ostringstream fieldoss;
fieldoss<<"stdB"<<i+1;
OGRFieldDefn field(fieldoss.str().c_str(), OFTReal);
layer.CreateField(field, true);
}
for(unsigned int i = 0; i < referenceImage->GetNumberOfComponentsPerPixel(); i++)
{
std::ostringstream fieldoss;
fieldoss<<"MedB"<<i+1;
OGRFieldDefn field(fieldoss.str().c_str(), OFTReal);
layer.CreateField(field, true);
}
for(unsigned int i = 0; i < referenceImage->GetNumberOfComponentsPerPixel(); i++)
{
std::ostringstream fieldoss;
fieldoss<<"VarB"<<i+1;
OGRFieldDefn field(fieldoss.str().c_str(), OFTReal);
layer.CreateField(field, true);
}
for(unsigned int i = 0; i < referenceImage->GetNumberOfComponentsPerPixel(); i++)
{
std::ostringstream fieldoss;
fieldoss<<"KurtB"<<i+1;
OGRFieldDefn field(fieldoss.str().c_str(), OFTReal);
layer.CreateField(field, true);
}
for(unsigned int i = 0; i < referenceImage->GetNumberOfComponentsPerPixel(); i++)
{
std::ostringstream fieldoss;
fieldoss<<"SkewB"<<i+1;
OGRFieldDefn field(fieldoss.str().c_str(), OFTReal);
layer.CreateField(field, true);
}
for(unsigned int i = 0; i < referenceImage->GetNumberOfComponentsPerPixel(); i++)
{
// Channel selection
m_ExtractROIFilter->SetChannel(i + 1);
// Statistics computation
StatisticsFilterType::Pointer statistics = StatisticsFilterType::New();
statistics->SetInput(converterStats->GetOutput());
statistics->SetFeatureImage(m_ExtractROIFilter->GetOutput());
statistics->SetComputePerimeter(true);
statistics->Update();
// Write shape attributes only one time
if(i==0)
{
for(otb::ogr::Layer::iterator featIt = layer.begin(); featIt!=layer.end(); ++featIt)
{
otb::ogr::Feature m_Feature = *featIt;
unsigned int label = m_Feature.ogr().GetFieldAsInteger(layer.GetLayerDefn().GetFieldIndex(GetParameterString("field").c_str()));
if(statistics->GetOutput()->HasLabel(label))
{
const StatisticsLabelObjectType *labelObjectStats = statistics->GetOutput()->GetLabelObject(label);
m_Feature.ogr().SetField("NbPixels", (int)labelObjectStats->GetNumberOfPixels());
m_Feature.ogr().SetField("Flat", labelObjectStats->GetFlatness());
m_Feature.ogr().SetField("Round", labelObjectStats->GetRoundness());
m_Feature.ogr().SetField("Elong", labelObjectStats->GetElongation());
m_Feature.ogr().SetField("Perim", labelObjectStats->GetPerimeter());
layer.SetFeature(m_Feature);
}
}
}
// Features iteration
for(otb::ogr::Layer::iterator featIt = layer.begin(); featIt!=layer.end(); ++featIt)
{
otb::ogr::Feature m_Feature = *featIt;
unsigned int label = m_Feature.ogr().GetFieldAsInteger(layer.GetLayerDefn().GetFieldIndex(GetParameterString("field").c_str()));
if(statistics->GetOutput()->HasLabel(label))
{
const StatisticsLabelObjectType *labelObjectStats = statistics->GetOutput()->GetLabelObject(label);
std::ostringstream fieldoss;
fieldoss<<"meanB"<<i+1;
m_Feature.ogr().SetField(fieldoss.str().c_str(),labelObjectStats->GetMean());
fieldoss.str("");
fieldoss<<"stdB"<<i+1;
m_Feature.ogr().SetField(fieldoss.str().c_str(),labelObjectStats->GetStandardDeviation());
fieldoss.str("");
fieldoss<<"medB"<<i+1;
m_Feature.ogr().SetField(fieldoss.str().c_str(),labelObjectStats->GetMedian());
fieldoss.str("");
fieldoss<<"varB"<<i+1;
m_Feature.ogr().SetField(fieldoss.str().c_str(),labelObjectStats->GetVariance());
fieldoss.str("");
fieldoss<<"kurtB"<<i+1;
m_Feature.ogr().SetField(fieldoss.str().c_str(),labelObjectStats->GetKurtosis());
fieldoss.str("");
fieldoss<<"skewB"<<i+1;
m_Feature.ogr().SetField(fieldoss.str().c_str(),labelObjectStats->GetSkewness());
fieldoss.str("");
}
else
{
otbAppLogINFO( << "Object number " << label << " is skipped. This could happen during the rasterisation process when an object is smaller than 1 pixel.");
}
}
}
}
void MaterialShaderGraph::AssembleShaderCode() {
std::vector<ShaderNode> shaderNodes(m_nodes.size());
std::vector<std::vector<MaterialShaderParameter>> shaderNodeParams(m_nodes.size());
std::vector<eMaterialShaderParamType> shaderNodeReturns(m_nodes.size());
std::vector<std::string> functions(m_nodes.size());
// collect individual shader codes and set number of input params for each node
for (size_t i = 0; i < m_nodes.size(); ++i) {
MaterialShader* shader = m_nodes[i].get();
functions[i] = shader->GetShaderCode();
ExtractShaderParameters(functions[i], "main", shaderNodeReturns[i], shaderNodeParams[i]);
for (auto p : shaderNodeParams[i]) {
if (p.type == eMaterialShaderParamType::UNKNOWN) {
throw InvalidArgumentException("Parameter of unknown type.");
}
}
shaderNodes[i].SetNumInputs(shaderNodeParams[i].size());
}
// link nodes together
for (const auto& link : m_links) {
ShaderNode& source = shaderNodes[link.sourceNode];
ShaderNode& sink = shaderNodes[link.sinkNode];
if (sink.GetNumInputs() <= link.sinkPort) {
throw InvalidArgumentException("Invalid link: port does not have that many inputs.");
}
bool isLinked = source.GetOutput(0)->Link(sink.GetInput(link.sinkPort));
if (!isLinked) {
throw InvalidArgumentException("Invalid link: duplicate input to a single port.");
}
}
// create output port LUT
std::unordered_map<OutputPortBase*, size_t> outputLut;
for (size_t i = 0; i < shaderNodes.size(); ++i) {
outputLut.insert({ shaderNodes[i].GetOutput(0), i });
}
// get the sink node
size_t sinkNodeIdx = -1;
for (size_t i = 0; i < shaderNodes.size(); ++i) {
if (shaderNodes[i].GetOutput(0)->begin() == shaderNodes[i].GetOutput(0)->end()) {
if (sinkNodeIdx != -1) {
throw InvalidArgumentException("Invalid graph: multiple sink nodes.");
}
sinkNodeIdx = i;
}
}
if (sinkNodeIdx == -1) {
throw InvalidArgumentException("Invalid graph: no sink nodes, contains circle.");
}
// run backwards DFS from sink node
// - get topological order
// - get list of free params
struct FreeParam {
size_t node, input;
std::string name;
};
std::vector<size_t> topologicalOrder;
std::vector<bool> visited(shaderNodes.size(), false);
std::vector<FreeParam> freeParams;
auto VisitNode = [&](size_t node, auto& self) {
if (visited[node]) {
return;
}
visited[node] = true;
for (int i = 0; i < shaderNodes[node].GetNumInputs(); ++i) {
auto* input = shaderNodes[node].GetInput(i);
if (input->GetLink() != nullptr) {
auto* linkOutput = input->GetLink();
size_t linkNode = outputLut[linkOutput];
self(linkNode, self);
}
else {
std::stringstream ss;
ss << m_nodes[node]->GetName() << "__" << shaderNodeParams[node][i].name;
static_cast<InputPort<std::string>*>(input)->Set(ss.str());
freeParams.push_back({ node, (size_t)i, ss.str() });
}
}
std::stringstream ss;
ss << "main_" << topologicalOrder.size();
shaderNodes[node].SetFunctionName(ss.str());
functions[node] = std::regex_replace(functions[node], std::regex("main"), ss.str());
topologicalOrder.push_back(node);
shaderNodes[node].SetFunctionReturn(GetParameterString(shaderNodeReturns[node]));
};
// attach final input port to sink node, and update according to topological order
InputPort<std::string> finalCodePort;
shaderNodes[sinkNodeIdx].GetOutput(0)->Link(&finalCodePort);
VisitNode(sinkNodeIdx, VisitNode);
for (auto idx : topologicalOrder) {
shaderNodes[idx].Update();
}
// assemble resulting code
std::stringstream finalCode;
// sub-functions
for (auto node : topologicalOrder) {
finalCode << functions[node] << "\n";
}
finalCode << "\n\n";
// signature
std::string returnType = GetParameterString(shaderNodeReturns[*--topologicalOrder.end()]);
finalCode << returnType << " main(";
bool firstParam = true;
for (auto& p : freeParams) {
if (!firstParam)
finalCode << ", ";
finalCode << GetParameterString(shaderNodeParams[p.node][p.input].type) << " ";
finalCode << p.name;
firstParam = false;
}
finalCode << ") {\n";
finalCode << "\n";
// preambles
for (auto idx : topologicalOrder) {
finalCode << " " << shaderNodes[idx].GetPreamble() << "\n";
}
finalCode << "\n";
// return statement
finalCode << "return " << finalCodePort.Get() << ";\n";
finalCode << "}\n";
m_source = finalCode.str();
}
CNewEnvironment::CNewEnvironment(const WeakStyleFilePtr& parent, const CString &name,int noOfParams)
: CLaTeXCommand(parent,name,noOfParams)
{
SetExpandBefore(CString(_T("\\begin{")));
SetExpandAfter(CString(_T("}") + CString(GetParameterString()) + _T("\r\n\r\n\\end{") + name + _T("}")));
}
void otb::Wrapper::Aggregate::DoExecute()
{
// Récupération de la labelmap
LabelImageType::Pointer labelIn = GetParameterUInt32Image("inseg");
labelIn->SetRequestedRegionToLargestPossibleRegion();
labelIn->Update();
// Filtre statistique pour récupérer le nombre de label dans la labelmap
StatisticsImageFilterType::Pointer stats = StatisticsImageFilterType::New();
stats->SetInput(labelIn);
stats->Update();
unsigned int regionCount=stats->GetMaximum();
otbAppLogINFO(<<"Number of objects: "<<regionCount);
//Récupération de la classification et statistique pour connaître le nombre de classes
ImageType::Pointer imageIn = GetParameterUInt32Image("in");
stats->SetInput(imageIn);
stats->Update();
unsigned int nbclass=stats->GetMaximum()-stats->GetMinimum()+1;
otbAppLogINFO(<<"Number of classes: "<<nbclass);
unsigned int minimum =stats->GetMinimum();
otbAppLogINFO(<<"Minimum: "<<minimum);
// Filtre LabelImage vers LabelMap(StatisticsLabelObject)
ConverterStatisticsType::Pointer converterStats = ConverterStatisticsType::New();
converterStats->SetInput(labelIn);
converterStats->SetBackgroundValue(0);
converterStats->Update();
// Calcul des statistiques par objet de la LabelMap
StatisticsFilterType::Pointer statistics = StatisticsFilterType::New();
statistics->SetInput(converterStats->GetOutput());
statistics->SetFeatureImage(imageIn);
statistics->SetNumberOfBins(nbclass);
statistics->Update();
// Définition du filtre ChangeLabel
m_ChangeLabelFilter = ChangeLabelImageFilterType::New();
m_ChangeLabelFilter->SetInput(labelIn);
// Iteration sur les objets, récupération de l'histogramme, extraction de la valeur mojoritaire
// Changement de la valeur du label par la valeur majoritaire dans la label map => obtention d'une classification corrigée
for(unsigned int i=0; i<regionCount+1; i++)
{
if(statistics->GetOutput()->HasLabel(i))
{
const StatisticsLabelObjectType *labelObjectStats = statistics->GetOutput()->GetLabelObject(i);
const HistogramType *histogram = labelObjectStats->GetHistogram();
unsigned int var = 0;
unsigned int classe = minimum;
for(unsigned int j=0; j< nbclass; j++)
{
if(histogram->GetFrequency(j)>var)
{
var = histogram->GetFrequency(j);
classe = j+minimum;
}
}
m_ChangeLabelFilter->SetChange(i,classe);
}
}
SetParameterOutputImage("outim", m_ChangeLabelFilter->GetOutput());
//Vectorisation
otbAppLogINFO(<<"Vectorization...");
//Définition du shapefile
const std::string shapefile = GetParameterString("out");
otb::ogr::DataSource::Pointer ogrDS;
otb::ogr::Layer layer(NULL, false);
std::string projRef = imageIn->GetProjectionRef();
OGRSpatialReference oSRS(projRef.c_str());
otbAppLogINFO(<< projRef);
std::vector<std::string> options;
ogrDS = otb::ogr::DataSource::New(shapefile, otb::ogr::DataSource::Modes::Overwrite);
std::string layername = itksys::SystemTools::GetFilenameName(shapefile.c_str());
std::string const extension = itksys::SystemTools::GetFilenameLastExtension(shapefile.c_str());
layername = layername.substr(0,layername.size()-(extension.size()));
layer = ogrDS->CreateLayer(layername, &oSRS, wkbMultiPolygon, options);
OGRFieldDefn labelField("label", OFTInteger);
layer.CreateField(labelField, true);
OGRFieldDefn MajorityField("Majority", OFTInteger);
layer.CreateField(MajorityField, true);
// Write label image
/*
WriterType::Pointer writer = WriterType::New();
writer->SetInput(m_ChangeLabelFilter->GetOutput());
writer->SetFileName("label_image.tif");
writer->Update();
*/
// Filtre LabelImage vers OGRDataSource
LabelImageToOGRDataSourceFilterType::Pointer labelToOGR = LabelImageToOGRDataSourceFilterType::New();
labelToOGR->SetInput(m_ChangeLabelFilter->GetOutput());
labelToOGR->SetInputMask(m_ChangeLabelFilter->GetOutput()); // La classe 0 est considérée comme du background et n'est pas vectorisée
labelToOGR->SetFieldName("Majority");
labelToOGR->Update();
otb::ogr::DataSource::ConstPointer ogrDSTmp = labelToOGR->GetOutput();
otb::ogr::Layer layerTmp = ogrDSTmp->GetLayerChecked(0);
otb::ogr::Layer::const_iterator featIt = layerTmp.begin();
int nveau_label = 1;
for(; featIt!=layerTmp.end(); ++featIt)
{
otb::ogr::Feature dstFeature(layer.GetLayerDefn());
dstFeature.SetFrom( *featIt, TRUE );
layer.CreateFeature( dstFeature );
dstFeature.ogr().SetField("label",nveau_label);
layer.SetFeature(dstFeature);
nveau_label +=1;
}
otbAppLogINFO(<<"Processing complete.");
}
//-----------------------------------------------------------------------------
/// Write a DX12-specific APITrace response line into the incoming string stream.
/// \param out The stringstream instance that each trace response line is written to.
/// \param inStartTime The start time for the API call.
/// \param inEndTime The end time for the API call.
//-----------------------------------------------------------------------------
void DX12APIEntry::AppendAPITraceLine(gtASCIIString& out, double inStartTime, double inEndTime) const
{
gtASCIIString returnValueString;
PrintReturnValue(mReturnValue, mReturnValueFlags, returnValueString);
// Use the database processor to get a pointer to the object database.
DX12ObjectDatabaseProcessor* databaseProcessor = DX12ObjectDatabaseProcessor::Instance();
DX12WrappedObjectDatabase* objectDatabase = static_cast<DX12WrappedObjectDatabase*>(databaseProcessor->GetObjectDatabase());
// Use the object database to retrieve wrapper info for the given interface.
IDX12InstanceBase* wrapperInfo = objectDatabase->GetMetadataObject(mWrapperInterface);
// APIType APIFunctionId InterfacePtr D3D12Interface_FunctionName(Parameters) = ReturnValue StartMillisecond EndMillisecond SampleId
void* handle = nullptr;
const char* type = "\0";
const char* parameters = GetParameterString();
if (wrapperInfo)
{
handle = wrapperInfo->GetApplicationHandle();
type = wrapperInfo->GetTypeAsString();
}
else
{
// if there's no wrapper, it's a Present call.
// Assume type is a swap chain until the Present call is wrapped properly
type = "IDXGISwapChain";
}
out += IntToString(DX12TraceAnalyzerLayer::Instance()->GetAPIGroupFromAPI(mFunctionId));
out += " ";
out += IntToString(mFunctionId);
out += " ";
out += "0x";
out += UINT64ToHexString((UINT64)handle);
out += " ";
out += type;
out += "_";
out += GetAPIName();
out += "(";
out += parameters;
out += ") = ";
out += returnValueString.asCharArray();
out += " ";
out += DoubleToString(inStartTime);
out += " ";
out += DoubleToString(inEndTime);
out += " ";
out += UINT64ToString(mSampleId);
out += "\n";
}
