v1.0.0-rc.36
This commit is contained in:
+124
-78
@@ -6,14 +6,13 @@
|
||||
#include "JFJochException.h"
|
||||
#include "JFJochCompressor.h"
|
||||
|
||||
PixelMask::PixelMask(const DetectorSetup &detector)
|
||||
: nmodules(detector.GetModulesNum()),
|
||||
mask(detector.GetModulesNum() * RAW_MODULE_SIZE, 0) {
|
||||
}
|
||||
PixelMask::PixelMask(size_t width, size_t height)
|
||||
: mask(width*height, 0) {}
|
||||
|
||||
PixelMask::PixelMask(const DiffractionExperiment &experiment)
|
||||
: PixelMask(experiment.GetDetectorSetup()) {
|
||||
Update(experiment.GetImageFormatSettings());
|
||||
: PixelMask(experiment.GetXPixelsNumConv(),
|
||||
experiment.GetYPixelsNumConv()) {
|
||||
CalcEdgePixels(experiment);
|
||||
}
|
||||
|
||||
uint32_t PixelMask::LoadMask(const std::vector<uint32_t> &input_mask, uint8_t bit) {
|
||||
@@ -32,67 +31,95 @@ uint32_t PixelMask::LoadMask(const std::vector<uint32_t> &input_mask, uint8_t bi
|
||||
return ret;
|
||||
}
|
||||
|
||||
void PixelMask::LoadDetectorBadPixelMask(const std::vector<uint32_t> &input_mask) {
|
||||
LoadMask(input_mask, ErrorPixelBit);
|
||||
void PixelMask::CalcEdgePixels(const DiffractionExperiment &experiment) {
|
||||
if (experiment.GetDetectorType() == DetectorType::DECTRIS)
|
||||
return;
|
||||
|
||||
size_t nmodules = experiment.GetModulesNum();
|
||||
auto settings = experiment.GetImageFormatSettings();
|
||||
|
||||
// Set module gaps to 1
|
||||
std::vector<uint32_t> module_gaps(nmodules * RAW_MODULE_SIZE, 0);
|
||||
std::vector<uint32_t> module_gaps_conv(experiment.GetPixelsNumConv(), 1);
|
||||
RawToConvertedGeometry(experiment, module_gaps_conv.data(), module_gaps.data());
|
||||
LoadMask(module_gaps_conv, ModuleGapPixelBit);
|
||||
|
||||
// Calculate module edges and chip edges
|
||||
std::vector<uint32_t> module_edge(nmodules * RAW_MODULE_SIZE, 0);
|
||||
std::vector<uint32_t> chip_edge(nmodules * RAW_MODULE_SIZE, 0);
|
||||
for (int64_t module = 0; module < nmodules; module++) {
|
||||
for (int64_t line = 0; line < RAW_MODULE_LINES; line++) {
|
||||
for (int64_t col = 0; col < RAW_MODULE_COLS; col++) {
|
||||
int64_t pixel = module * RAW_MODULE_SIZE + line * RAW_MODULE_COLS + col;
|
||||
if ((line == 0)
|
||||
|| (line == RAW_MODULE_LINES - 1)
|
||||
|| (col == 0)
|
||||
|| (col == RAW_MODULE_COLS - 1))
|
||||
module_edge[pixel] = 1;
|
||||
|
||||
if ((col == 255) || (col == 256)
|
||||
|| (col == 511) || (col == 512)
|
||||
|| (col == 767) || (col == 768)
|
||||
|| (line == 255) || (line == 256))
|
||||
chip_edge[pixel] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<uint32_t> module_edge_conv(experiment.GetPixelsNumConv(), 0);
|
||||
if (experiment.GetMaskModuleEdges())
|
||||
RawToConvertedGeometry(experiment, module_edge_conv.data(), module_edge.data());
|
||||
LoadMask(module_edge_conv, ModuleEdgePixelBit);
|
||||
|
||||
std::vector<uint32_t> chip_edge_conv(experiment.GetPixelsNumConv(), 0);
|
||||
if (experiment.GetMaskChipEdges())
|
||||
RawToConvertedGeometry(experiment, chip_edge_conv.data(), chip_edge.data());
|
||||
LoadMask(chip_edge_conv, ChipGapPixelBit);
|
||||
}
|
||||
|
||||
const std::vector<uint32_t> &PixelMask::GetMaskRaw() const {
|
||||
std::vector<uint32_t> PixelMask::GetMaskRaw(const DiffractionExperiment &experiment) const {
|
||||
std::vector<uint32_t> ret(experiment.GetModulesNum() * RAW_MODULE_SIZE, 0);
|
||||
ConvertedToRawGeometry(experiment, ret.data(), mask.data());
|
||||
return ret;
|
||||
}
|
||||
|
||||
const std::vector<uint32_t> &PixelMask::GetMask() const {
|
||||
return mask;
|
||||
}
|
||||
|
||||
std::vector<uint32_t> PixelMask::GetMask(const DiffractionExperiment &experiment) const {
|
||||
if (experiment.IsGeometryTransformed()) {
|
||||
std::vector<uint32_t> tmp(experiment.GetPixelsNum(), 1 << ModuleGapPixelBit);
|
||||
// nonfunctional areas (i.e. gaps) are filled with 1
|
||||
RawToConvertedGeometry<uint32_t, uint32_t>(experiment, tmp.data(), mask.data());
|
||||
return tmp;
|
||||
} else
|
||||
return mask;
|
||||
}
|
||||
|
||||
std::vector<uint8_t> PixelMask::GetCompressedMask(const DiffractionExperiment &experiment) const {
|
||||
JFJochBitShuffleCompressor compressor(CompressionAlgorithm::BSHUF_LZ4);
|
||||
return compressor.Compress(GetMask(experiment));
|
||||
}
|
||||
|
||||
std::vector<uint32_t> PixelMask::GetUserMask(const DiffractionExperiment &experiment, bool conv) const {
|
||||
std::vector<uint32_t> ret;
|
||||
|
||||
if (conv)
|
||||
ret = GetMask(experiment);
|
||||
std::vector<uint32_t> PixelMask::GetMask(const DiffractionExperiment& experiment) const {
|
||||
if (experiment.IsGeometryTransformed())
|
||||
return GetMask();
|
||||
else
|
||||
ret = GetMaskRaw();
|
||||
return GetMaskRaw(experiment);
|
||||
}
|
||||
|
||||
std::vector<uint32_t> PixelMask::GetUserMask() const {
|
||||
std::vector<uint32_t> ret = GetMask();
|
||||
for (auto &i: ret)
|
||||
i = ((i & (1 << UserMaskedPixelBit)) != 0) ? 1 : 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
PixelMaskStatistics PixelMask::GetStatistics() const {
|
||||
return statistics;
|
||||
std::vector<uint32_t> PixelMask::GetUserMask(const DiffractionExperiment& experiment) const {
|
||||
if (experiment.IsGeometryTransformed())
|
||||
return GetUserMask();
|
||||
else {
|
||||
std::vector<uint32_t> tmp = GetUserMask();
|
||||
std::vector<uint32_t> ret(experiment.GetModulesNum() * RAW_MODULE_SIZE, 0);
|
||||
ConvertedToRawGeometry(experiment, ret.data(), tmp.data());
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
void PixelMask::LoadUserMask(const DiffractionExperiment &experiment,
|
||||
const std::vector<uint32_t> &in_mask) {
|
||||
DiffractionExperiment tmp_experiment = experiment;
|
||||
tmp_experiment.GeometryTransformation(true);
|
||||
|
||||
if (tmp_experiment.GetModulesNum() != nmodules)
|
||||
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
||||
"Mismatch in module size");
|
||||
|
||||
if (in_mask.size() == nmodules * RAW_MODULE_SIZE) {
|
||||
statistics.user_mask = LoadMask(in_mask, UserMaskedPixelBit);
|
||||
} else if (in_mask.size() == tmp_experiment.GetPixelsNum()) {
|
||||
std::vector<uint32_t> raw_mask(nmodules * RAW_MODULE_SIZE);
|
||||
ConvertedToRawGeometry(tmp_experiment, raw_mask.data(), in_mask.data());
|
||||
statistics.user_mask = LoadMask(raw_mask, UserMaskedPixelBit);
|
||||
} else
|
||||
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
||||
"Size of input user mask invalid");
|
||||
}
|
||||
|
||||
void PixelMask::LoadDetectorBadPixelMask(const DiffractionExperiment &experiment, const JFCalibration *calib) {
|
||||
if (experiment.GetDetectorType() == DetectorType::DECTRIS) {
|
||||
statistics.wrong_gain = 0;
|
||||
statistics.too_high_pedestal_rms = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector<uint32_t> input_mask(experiment.GetModulesNum() * RAW_MODULE_SIZE, 0);
|
||||
std::vector<uint32_t> input_mask_rms(experiment.GetModulesNum() * RAW_MODULE_SIZE, 0);
|
||||
|
||||
@@ -122,37 +149,56 @@ void PixelMask::LoadDetectorBadPixelMask(const DiffractionExperiment &experiment
|
||||
}
|
||||
}
|
||||
|
||||
statistics.wrong_gain = LoadMask(input_mask, ErrorPixelBit);
|
||||
statistics.too_high_pedestal_rms = LoadMask(input_mask_rms, TooHighPedestalRMSPixelBit);
|
||||
Update(experiment.GetImageFormatSettings());
|
||||
std::vector<uint32_t> input_mask_conv(experiment.GetPixelsNumConv(), 0);
|
||||
RawToConvertedGeometry(experiment, input_mask_conv.data(), input_mask.data());
|
||||
statistics.wrong_gain = LoadMask(input_mask_conv, ErrorPixelBit);
|
||||
|
||||
std::vector<uint32_t> input_mask_rms_conv(experiment.GetPixelsNumConv(), 0);
|
||||
RawToConvertedGeometry(experiment, input_mask_rms_conv.data(), input_mask_rms.data());
|
||||
statistics.too_high_pedestal_rms = LoadMask(input_mask_rms_conv, TooHighPedestalRMSPixelBit);
|
||||
|
||||
CalcEdgePixels(experiment);
|
||||
}
|
||||
|
||||
void PixelMask::Update(const ImageFormatSettings &settings) {
|
||||
std::vector<uint32_t> module_edge(nmodules * RAW_MODULE_SIZE, 0);
|
||||
std::vector<uint32_t> chip_edge(nmodules * RAW_MODULE_SIZE, 0);
|
||||
|
||||
// apply edge mask
|
||||
for (int64_t module = 0; module < nmodules; module++) {
|
||||
for (int64_t line = 0; line < RAW_MODULE_LINES; line++) {
|
||||
for (int64_t col = 0; col < RAW_MODULE_COLS; col++) {
|
||||
int64_t pixel = module * RAW_MODULE_SIZE + line * RAW_MODULE_COLS + col;
|
||||
PixelMaskStatistics PixelMask::GetStatistics() const {
|
||||
return statistics;
|
||||
}
|
||||
|
||||
if (settings.IsMaskModuleEdges())
|
||||
if ((line == 0)
|
||||
|| (line == RAW_MODULE_LINES - 1)
|
||||
|| (col == 0)
|
||||
|| (col == RAW_MODULE_COLS - 1))
|
||||
module_edge[pixel] = 1;
|
||||
void PixelMask::LoadUserMask(const DiffractionExperiment& experiment, const std::vector<uint32_t> &in_mask) {
|
||||
if (in_mask.size() == mask.size()) {
|
||||
statistics.user_mask = LoadMask(in_mask, UserMaskedPixelBit);
|
||||
} else if (in_mask.size() == experiment.GetModulesNum() * RAW_MODULE_SIZE) {
|
||||
std::vector<uint32_t> tmp(experiment.GetPixelsNumConv(), 0);
|
||||
RawToConvertedGeometry(experiment, tmp.data(), in_mask. data());
|
||||
statistics.user_mask = LoadMask(tmp, UserMaskedPixelBit);
|
||||
} else
|
||||
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
||||
"Size of input user mask invalid");
|
||||
}
|
||||
|
||||
if (settings.IsMaskChipEdges())
|
||||
if ((col == 255) || (col == 256)
|
||||
|| (col == 511) || (col == 512)
|
||||
|| (col == 767) || (col == 768)
|
||||
|| (line == 255) || (line == 256))
|
||||
chip_edge[pixel] = 1;
|
||||
}
|
||||
}
|
||||
void PixelMask::LoadDECTRISBadPixelMask(const std::vector<uint32_t> &input_mask) {
|
||||
if (input_mask.size() != mask.size())
|
||||
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
||||
"Input match doesn't fit the detector ");
|
||||
|
||||
uint32_t user_bitmask = (1 << UserMaskedPixelBit);
|
||||
uint32_t det_bitmask = ~user_bitmask;
|
||||
uint32_t bad_pixel_bitmask = ~((1 << UserMaskedPixelBit) | (1 << ModuleGapPixelBit) | (1 << ChipGapPixelBit));
|
||||
|
||||
statistics.user_mask = 0;
|
||||
statistics.wrong_gain = 0;
|
||||
statistics.too_high_pedestal_rms = 0;
|
||||
|
||||
for (int i = 0; i < mask.size(); i++) {
|
||||
uint32_t user_mask = (mask[i] & user_bitmask);
|
||||
if (user_mask != 0)
|
||||
++statistics.user_mask;
|
||||
uint32_t detector_mask = (input_mask[i] & det_bitmask);
|
||||
uint32_t bad_pixel = (input_mask[i] & bad_pixel_bitmask);
|
||||
if (bad_pixel != 0)
|
||||
++statistics.wrong_gain;
|
||||
|
||||
mask[i] = user_mask | detector_mask;
|
||||
}
|
||||
LoadMask(module_edge, ModuleEdgePixelBit);
|
||||
LoadMask(chip_edge, ChipGapPixelBit);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user