Skip to content

Commit

Permalink
Code cleanup in VRTKernelFilteredSource
Browse files Browse the repository at this point in the history
  • Loading branch information
@rouault
rouault committed Jun 20, 2024
1 parent c83797a commit 1bfce62
Show file tree
Hide file tree
Showing 2 changed files with 39 additions and 62 deletions.
18 changes: 8 additions & 10 deletions frmts/vrt/vrtdataset.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1601,17 +1601,14 @@ class VRTKernelFilteredSource CPL_NON_FINAL : public VRTFilteredSource
CPL_DISALLOW_COPY_ASSIGN(VRTKernelFilteredSource)

protected:
int m_nKernelSize;

bool m_bSeparable;

double *m_padfKernelCoefs;

int m_bNormalized;
int m_nKernelSize = 0;
bool m_bSeparable = false;
// m_nKernelSize elements if m_bSeparable, m_nKernelSize * m_nKernelSize otherwise
std::vector<double> m_adfKernelCoefs{};
bool m_bNormalized = false;

public:
VRTKernelFilteredSource();
virtual ~VRTKernelFilteredSource();

virtual CPLErr XMLInit(const CPLXMLNode *psTree, const char *,
std::map<CPLString, GDALDataset *> &) override;
Expand All @@ -1620,8 +1617,9 @@ class VRTKernelFilteredSource CPL_NON_FINAL : public VRTFilteredSource
virtual CPLErr FilterData(int nXSize, int nYSize, GDALDataType eType,
GByte *pabySrcData, GByte *pabyDstData) override;

CPLErr SetKernel(int nKernelSize, bool bSeparable, double *padfCoefs);
void SetNormalized(int);
CPLErr SetKernel(int nKernelSize, bool bSeparable,
const std::vector<double> &adfNewCoefs);
void SetNormalized(bool);
};

/************************************************************************/
Expand Down
83 changes: 31 additions & 52 deletions frmts/vrt/vrtfilters.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -420,28 +420,16 @@ CPLErr VRTFilteredSource::RasterIO(GDALDataType eVRTBandDataType, int nXOff,
/************************************************************************/

VRTKernelFilteredSource::VRTKernelFilteredSource()
: m_nKernelSize(0), m_bSeparable(FALSE), m_padfKernelCoefs(nullptr),
m_bNormalized(FALSE)
{
GDALDataType aeSupTypes[] = {GDT_Float32};
SetFilteringDataTypesSupported(1, aeSupTypes);
}

/************************************************************************/
/* ~VRTKernelFilteredSource() */
/************************************************************************/

VRTKernelFilteredSource::~VRTKernelFilteredSource()

{
CPLFree(m_padfKernelCoefs);
}

/************************************************************************/
/* SetNormalized() */
/************************************************************************/

void VRTKernelFilteredSource::SetNormalized(int bNormalizedIn)
void VRTKernelFilteredSource::SetNormalized(bool bNormalizedIn)

{
m_bNormalized = bNormalizedIn;
Expand All @@ -451,8 +439,9 @@ void VRTKernelFilteredSource::SetNormalized(int bNormalizedIn)
/* SetKernel() */
/************************************************************************/

CPLErr VRTKernelFilteredSource::SetKernel(int nNewKernelSize, bool bSeparable,
double *padfNewCoefs)
CPLErr
VRTKernelFilteredSource::SetKernel(int nNewKernelSize, bool bSeparable,
const std::vector<double> &adfNewCoefs)

{
if (nNewKernelSize < 1 || (nNewKernelSize % 2) != 1)
Expand All @@ -463,16 +452,17 @@ CPLErr VRTKernelFilteredSource::SetKernel(int nNewKernelSize, bool bSeparable,
nNewKernelSize);
return CE_Failure;
}
if (adfNewCoefs.size() !=
static_cast<size_t>(nNewKernelSize) * (bSeparable ? 1 : nNewKernelSize))
{
CPLError(CE_Failure, CPLE_AppDefined,
"adfNewCoefs[] is not of expected size");
return CE_Failure;
}

CPLFree(m_padfKernelCoefs);
m_nKernelSize = nNewKernelSize;
m_bSeparable = bSeparable;

int nKernelBufferSize = m_nKernelSize * (m_bSeparable ? 1 : m_nKernelSize);

m_padfKernelCoefs =
static_cast<double *>(CPLMalloc(sizeof(double) * nKernelBufferSize));
memcpy(m_padfKernelCoefs, padfNewCoefs, sizeof(double) * nKernelBufferSize);
m_adfKernelCoefs = adfNewCoefs;

SetExtraEdgePixels((nNewKernelSize - 1) / 2);

Expand Down Expand Up @@ -565,8 +555,8 @@ CPLErr VRTKernelFilteredSource::FilterData(int nXSize, int nYSize,
iJJ * nJStride;
if (bHasNoData && *pfData == fNoData)
continue;
dfSum += *pfData * m_padfKernelCoefs[iK];
dfKernSum += m_padfKernelCoefs[iK];
dfSum += *pfData * m_adfKernelCoefs[iK];
dfKernSum += m_adfKernelCoefs[iK];
}
}

Expand Down Expand Up @@ -618,17 +608,16 @@ CPLErr VRTKernelFilteredSource::XMLInit(
return CE_Failure;
}

char **papszCoefItems =
CSLTokenizeString(CPLGetXMLValue(psTree, "Kernel.Coefs", ""));
const CPLStringList aosCoefItems(
CSLTokenizeString(CPLGetXMLValue(psTree, "Kernel.Coefs", "")));

const int nCoefs = CSLCount(papszCoefItems);
const int nCoefs = aosCoefItems.size();

const bool bSquare = nCoefs == nNewKernelSize * nNewKernelSize;
const bool bSeparable = nCoefs == nNewKernelSize && nCoefs != 1;

if (!bSquare && !bSeparable)
{
CSLDestroy(papszCoefItems);
CPLError(CE_Failure, CPLE_AppDefined,
"Got wrong number of filter kernel coefficients (%s). "
"Expected %d or %d, got %d.",
Expand All @@ -637,19 +626,17 @@ CPLErr VRTKernelFilteredSource::XMLInit(
return CE_Failure;
}

double *padfNewCoefs =
static_cast<double *>(CPLMalloc(sizeof(double) * nCoefs));

std::vector<double> adfNewCoefs;
adfNewCoefs.reserve(nCoefs);
for (int i = 0; i < nCoefs; i++)
padfNewCoefs[i] = CPLAtof(papszCoefItems[i]);

const CPLErr eErr = SetKernel(nNewKernelSize, bSeparable, padfNewCoefs);

CPLFree(padfNewCoefs);
CSLDestroy(papszCoefItems);

SetNormalized(atoi(CPLGetXMLValue(psTree, "Kernel.normalized", "0")));
adfNewCoefs.push_back(CPLAtof(aosCoefItems[i]));

const CPLErr eErr = SetKernel(nNewKernelSize, bSeparable, adfNewCoefs);
if (eErr == CE_None)
{
SetNormalized(atoi(CPLGetXMLValue(psTree, "Kernel.normalized", "0")) !=
0);
}
return eErr;
}

Expand All @@ -673,23 +660,15 @@ CPLXMLNode *VRTKernelFilteredSource::SerializeToXML(const char *pszVRTPath)

CPLXMLNode *psKernel = CPLCreateXMLNode(psSrc, CXT_Element, "Kernel");

if (m_bNormalized)
CPLCreateXMLNode(
CPLCreateXMLNode(psKernel, CXT_Attribute, "normalized"), CXT_Text,
"1");
else
CPLCreateXMLNode(
CPLCreateXMLNode(psKernel, CXT_Attribute, "normalized"), CXT_Text,
"0");

const int nCoefCount =
m_bSeparable ? m_nKernelSize : m_nKernelSize * m_nKernelSize;
CPLCreateXMLNode(CPLCreateXMLNode(psKernel, CXT_Attribute, "normalized"),
CXT_Text, m_bNormalized ? "1" : "0");

std::string osCoefs;
for (int iCoef = 0; iCoef < nCoefCount; iCoef++)
for (auto dfVal : m_adfKernelCoefs)
{
if (!osCoefs.empty())
osCoefs += ' ';
osCoefs += CPLSPrintf("%.8g", m_padfKernelCoefs[iCoef]);
osCoefs += CPLSPrintf("%.8g", dfVal);
}

CPLSetXMLValue(psKernel, "Size", CPLSPrintf("%d", m_nKernelSize));
Expand Down

0 comments on commit 1bfce62

Please sign in to comment.