first level test

python/src/detector.cpp

@@ -924,17 +924,6 @@ void init_det(py::module &m) {
                        (void (Detector::*)(bool, sls::Positions)) &
                            Detector::setRxArping,
                        py::arg(), py::arg() = Positions{});
-    CppDetectorApi.def("getIndividualRxROIs",
-                       (Result<defs::ROI>(Detector::*)(sls::Positions) const) &
-                           Detector::getIndividualRxROIs,
-                       py::arg());
-    CppDetectorApi.def("getRxROI",
-                       (defs::ROI(Detector::*)() const) & Detector::getRxROI);
-    CppDetectorApi.def(
-        "setRxROI", (void (Detector::*)(const defs::ROI)) & Detector::setRxROI,
-        py::arg());
-    CppDetectorApi.def("clearRxROI",
-                       (void (Detector::*)()) & Detector::clearRxROI);
     CppDetectorApi.def(
         "getFileFormat",
         (Result<defs::fileFormat>(Detector::*)(sls::Positions) const) &

slsDetectorSoftware/generator/Caller.in.h

@@ -21,6 +21,7 @@ class Caller {
     UdpDestination getUdpEntry();
     int GetLevelAndInsertIntoArgs(std::string levelSeparatedCommand);
     void WrongNumberOfParameters(size_t expected);
+    std::vector<defs::ROI> parseRoiVector(const std::string &input);
 
     template <typename V> std::string OutStringHex(const V &value) {
         if (value.equal())

slsDetectorSoftware/generator/commands.yaml

@@ -2598,11 +2598,7 @@ rx_roi:
         GET:
           argc: 0
         PUT:
-          args:
-            - argc: 2
-              arg_types: [ int, int ]
-            - argc: 4
-              arg_types: [ int, int, int, int ]
+          argc: -1
 
 ratecorr:
     is_description: true

slsDetectorSoftware/include/sls/Detector.h

@@ -119,6 +119,10 @@ class Detector {
 
     Result<defs::xy> getModuleSize(Positions pos = {}) const;
 
+    defs::xy getPortPerModuleGeometry() const;
+
+    Result<defs::xy> getPortSize(Positions pos = {}) const;
+
     /** Gets the actual full detector size. It is the same even if ROI changes
      */
     defs::xy getDetectorSize() const;
@@ -985,16 +989,15 @@ class Detector {
      * every minute. Useful in 10G mode. */
     void setRxArping(bool value, Positions pos = {});
 
-    /** at module level */
-    Result<defs::ROI> getIndividualRxROIs(Positions pos) const;
-
-    defs::ROI getRxROI() const;
+    std::vector<defs::ROI> getRxROI() const;
 
     /** only at multi module level without gap pixels */
-    void setRxROI(const defs::ROI value);
+    void setRxROI(const std::vector<defs::ROI> &args);
 
     void clearRxROI();
 
+    int getNumberOfUdpPortsInRxROI() const;
+
     ///@}
 
     /** @name File */

slsDetectorSoftware/src/Caller.h

@@ -21,6 +21,7 @@ class Caller {
     UdpDestination getUdpEntry();
     int GetLevelAndInsertIntoArgs(std::string levelSeparatedCommand);
     void WrongNumberOfParameters(size_t expected);
+    std::vector<defs::ROI> parseRoiVector(const std::string &input);
 
     template <typename V> std::string OutStringHex(const V &value) {
         if (value.equal())

slsDetectorSoftware/src/CallerSpecial.cpp

@@ -719,49 +719,126 @@ std::string Caller::rx_zmqip(int action) {
     }
     return os.str();
 }
+
 std::string Caller::rx_roi(int action) {
     std::ostringstream os;
+    std::string helpMessage = std::string("[xmin] [xmax] [ymin] [ymax]\n\tRegion of interest in receiver.\n\t")
+           + "For a list of rois, use '[' and ']; ' to distinguish between "
+              "rois and use comma inside the square brackets.\n\t If one fails to use space after semicolon, please use quotes"
+           + "For example: [0,100,0,100]; [200,300,0,100] will set two "
+              "rois.or '[0,100,0,100];[200,300,0,100]' when the vector is a single string\n\t"
+           + "Only allowed at multi module level and without gap "
+              "pixels.\n";
     if (action == defs::HELP_ACTION) {
-        os << "[xmin] [xmax] [ymin] [ymax]\n\tRegion of interest in "
-              "receiver.\n\tOnly allowed at multi module level and without gap "
-              "pixels."
-           << '\n';
+        os << helpMessage;
     } else if (action == defs::GET_ACTION) {
         if (!args.empty()) {
             WrongNumberOfParameters(0);
         }
-        if (det_id == -1) {
-            auto t = det->getRxROI();
-            os << t << '\n';
+        if (det_id != -1) {
+            throw RuntimeError("Cannot execute receiver ROI at module level");
         } else {
-            auto t = det->getIndividualRxROIs(std::vector<int>{det_id});
-            os << t << '\n';
+            auto t = det->getRxROI();
+            // os << ToString(t) << '\n';
+            for (const auto &r : t) {
+                os << r << ';';
+            }
+            if (!t.empty()) {
+                os.seekp(-1, std::ios_base::end); // remove trailing ;
+            }
+            os << '\n';
         }
     } else if (action == defs::PUT_ACTION) {
-        defs::ROI t;
-        // 2 or 4 arguments
-        if (args.size() != 2 && args.size() != 4) {
-            WrongNumberOfParameters(2);
-        }
-        if (args.size() == 2 || args.size() == 4) {
-            t.xmin = StringTo<int>(args[0]);
-            t.xmax = StringTo<int>(args[1]);
-        }
-        if (args.size() == 4) {
-            t.ymin = StringTo<int>(args[2]);
-            t.ymax = StringTo<int>(args[3]);
+        std::vector<defs::ROI> rois;
+
+        // Support multiple args with bracketed ROIs, or single arg with
+        // semicolon-separated vector
+        bool isVectorInput =
+            std::all_of(args.begin(), args.end(), [](const std::string &a) {
+                return a.find('[') != std::string::npos &&
+                       a.find(']') != std::string::npos;
+            });
+        try {
+            // previous format: 2 or 4 separate args
+            if ((args.size() == 2 || args.size() == 4) && !isVectorInput) {
+                defs::ROI t;
+                t.xmin = StringTo<int>(args[0]);
+                t.xmax = StringTo<int>(args[1]);
+                if (args.size() == 4) {
+                    t.ymin = StringTo<int>(args[2]);
+                    t.ymax = StringTo<int>(args[3]);
+                }
+                rois.emplace_back(t);
+            } else {
+                if (!isVectorInput)
+                    WrongNumberOfParameters(2);
+                else {
+                    for (const auto &arg : args) {
+                        auto subRois = parseRoiVector(arg);
+                        rois.insert(rois.end(), subRois.begin(), subRois.end());
+                    }
+                }
+            }
+        } catch (const std::exception &e) {
+            throw RuntimeError("Could not parse ROI: " + helpMessage);
         }
+
         // only multi level
         if (det_id != -1) {
             throw RuntimeError("Cannot execute receiver ROI at module level");
         }
-        det->setRxROI(t);
-        os << t << '\n';
+
+        det->setRxROI(rois);
+        // os << ToString(rois) << '\n';
+        for (const auto &r : rois) {
+            os << r << ';';
+        }
+        //if (!rois.empty()) {
+       //     os.seekp(-1, std::ios_base::end); // remove trailing ;
+        //}
+        os << '\n';
     } else {
         throw RuntimeError("Unknown action");
     }
     return os.str();
 }
+
+std::vector<defs::ROI> Caller::parseRoiVector(const std::string &input) {
+    std::vector<defs::ROI> rois;
+    std::stringstream ss(input);
+    std::string token;
+
+    while (std::getline(ss, token, ';')) {
+        token.erase(std::remove_if(token.begin(), token.end(), ::isspace),
+                    token.end());
+        if (token.empty())
+            continue;
+        if (token.front() != '[' || token.back() != ']') {
+            throw RuntimeError("Each ROI must be enclosed in square brackets: "
+                               "[xmin,xmax,ymin,ymax]");
+        }
+        token = token.substr(1, token.size() - 2); // remove brackets
+        std::vector<std::string> parts;
+        std::stringstream inner(token);
+        std::string num;
+        while (std::getline(inner, num, ',')) {
+            parts.push_back(num);
+        }
+
+        if (parts.size() != 4) {
+            throw RuntimeError("ROI must have 4 comma-separated integers");
+        }
+
+        defs::ROI roi;
+        roi.xmin = StringTo<int>(parts[0]);
+        roi.xmax = StringTo<int>(parts[1]);
+        roi.ymin = StringTo<int>(parts[2]);
+        roi.ymax = StringTo<int>(parts[3]);
+        rois.emplace_back(roi);
+    }
+    return rois;
+}
+
 std::string Caller::ratecorr(int action) {
     std::ostringstream os;
     if (action == defs::HELP_ACTION) {

slsDetectorSoftware/src/Detector.cpp

@@ -201,6 +201,22 @@ Result<defs::xy> Detector::getModuleSize(Positions pos) const {
     return pimpl->Parallel(&Module::getNumberOfChannels, pos);
 }
 
+defs::xy Detector::getPortPerModuleGeometry() const {
+    return pimpl->getPortGeometry();
+}
+
+Result<defs::xy> Detector::getPortSize(Positions pos) const {
+    Result<defs::xy> res = pimpl->Parallel(&Module::getNumberOfChannels, pos);
+    defs::xy portGeometry = getPortPerModuleGeometry();
+    for (auto &it : res) {
+        if (portGeometry.x == 2)
+            it.x /= 2;
+        if (portGeometry.y == 2)
+            it.y /= 2;
+    }
+    return res;
+}
+
 defs::xy Detector::getDetectorSize() const {
     return pimpl->getNumberOfChannels();
 }
@@ -1367,16 +1383,19 @@ void Detector::setRxArping(bool value, Positions pos) {
     pimpl->Parallel(&Module::setRxArping, pos, value);
 }
 
-Result<defs::ROI> Detector::getIndividualRxROIs(Positions pos) const {
-    return pimpl->Parallel(&Module::getRxROI, pos);
+std::vector<defs::ROI> Detector::getRxROI() const { return pimpl->getRxROI(); }
+
+// RxROIs can be set for all types except CTB. At multi level without gap pixels
+void Detector::setRxROI(const std::vector<defs::ROI> &args) {
+    pimpl->setRxROI(args);
 }
 
-defs::ROI Detector::getRxROI() const { return pimpl->getRxROI(); }
-
-void Detector::setRxROI(const defs::ROI value) { pimpl->setRxROI(value); }
-
 void Detector::clearRxROI() { pimpl->clearRxROI(); }
 
+int Detector::getNumberOfUdpPortsInRxROI() const {
+    return pimpl->getNumberOfUdpPortsInRxROI();
+}
+
 // File
 
 Result<defs::fileFormat> Detector::getFileFormat(Positions pos) const {

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -130,10 +130,6 @@ void DetectorImpl::initializeDetectorStructure() {
     shm()->gapPixels = false;
     // zmqlib default
     shm()->zmqHwm = -1;
-    shm()->rx_roi.xmin = -1;
-    shm()->rx_roi.xmax = -1;
-    shm()->rx_roi.ymin = -1;
-    shm()->rx_roi.ymax = -1;
 }
 
 void DetectorImpl::initializeMembers(bool verify) {
@@ -539,7 +535,7 @@ void DetectorImpl::readFrameFromReceiver() {
     bool quadEnable = false;
     // to flip image
     bool eiger = false;
-    std::array<int, 4> rxRoi = shm()->rx_roi.getIntArray();
+    std::array<int, 4> rxRoi{}; // TODO: get roi from json header
 
     std::vector<bool> runningList(zmqSocket.size());
     std::vector<bool> connectList(zmqSocket.size());
@@ -1548,31 +1544,6 @@ void DetectorImpl::setDefaultDac(defs::dacIndex index, int defaultValue,
     Parallel(&Module::setDefaultDac, pos, index, defaultValue, sett);
 }
 
-defs::xy DetectorImpl::getPortGeometry() const {
-    defs::xy portGeometry(1, 1);
-    switch (shm()->detType) {
-    case EIGER:
-        portGeometry.x = modules[0]->getNumberofUDPInterfacesFromShm();
-        break;
-    case JUNGFRAU:
-    case MOENCH:
-        portGeometry.y = modules[0]->getNumberofUDPInterfacesFromShm();
-        break;
-    default:
-        break;
-    }
-    return portGeometry;
-}
-
-defs::xy DetectorImpl::calculatePosition(int moduleIndex,
-                                         defs::xy geometry) const {
-    defs::xy pos{};
-    int maxYMods = shm()->numberOfModules.y;
-    pos.y = (moduleIndex % maxYMods) * geometry.y;
-    pos.x = (moduleIndex / maxYMods) * geometry.x;
-    return pos;
-}
-
 void DetectorImpl::verifyUniqueDetHost(const uint16_t port,
                                        std::vector<int> positions) const {
     // port for given positions
@@ -1696,7 +1667,8 @@ void DetectorImpl::verifyUniqueHost(
     }
 }
 
-defs::ROI DetectorImpl::getRxROI() const {
+std::vector<defs::ROI> DetectorImpl::getRxROI() const {
+
     if (shm()->detType == CHIPTESTBOARD ||
         shm()->detType == defs::XILINX_CHIPTESTBOARD) {
         throw RuntimeError("RxRoi not implemented for this Detector");
@@ -1704,75 +1676,172 @@ defs::ROI DetectorImpl::getRxROI() const {
     if (modules.size() == 0) {
         throw RuntimeError("No Modules added");
     }
-    // complete detector in roi
-    auto t = Parallel(&Module::getRxROI, {});
-    if (t.equal() && t.front().completeRoi()) {
-        LOG(logDEBUG) << "no roi";
-        return defs::ROI(0, shm()->numberOfChannels.x - 1, 0,
-                         shm()->numberOfChannels.y - 1);
-    }
 
-    defs::xy numChansPerMod = modules[0]->getNumberOfChannels();
-    bool is2D = (numChansPerMod.y > 1 ? true : false);
-    defs::xy geometry = getPortGeometry();
+    // return std::vector<defs::ROI>{};
+    return rxRoiTemp;
+    // TODO
+}
 
-    defs::ROI retval{};
-    for (size_t iModule = 0; iModule != modules.size(); ++iModule) {
+bool DetectorImpl::roisOverlap(const defs::ROI &a, const defs::ROI &b) const {
+    bool xOverlap = !(a.xmax < b.xmin || a.xmin > b.xmax);
+    bool yOverlap = !(a.ymax < b.ymin || a.ymin > b.ymax);
+    return xOverlap && yOverlap;
+}
 
-        defs::ROI moduleRoi = modules[iModule]->getRxROI();
-        if (moduleRoi.noRoi()) {
-            LOG(logDEBUG) << iModule << ": no roi";
+void DetectorImpl::validateROIs(const std::vector<defs::ROI> &rois) {
+    for (size_t i = 0; i < rois.size(); ++i) {
+        const auto &roi = rois[i];
+
+        if (roi.noRoi()) {
+            throw RuntimeError("Invalid Roi of size 0. Roi: " + ToString(roi));
+        }
+        bool is2D = (modules[0]->getNumberOfChannels().y > 1 ? true : false);
+        if (roi.completeRoi()) {
+            std::ostringstream oss;
+            oss << "Did you mean the clear roi command (API: clearRxROI, cmd: "
+                   "rx_clearroi) Roi: [ -1, -1 ";
+            oss << (is2D ? ", -1, -1 ]?" : "]?");
+            throw RuntimeError(oss.str());
+        }
+        if (roi.xmin > roi.xmax || roi.ymin > roi.ymax) {
+            throw RuntimeError(
+                "Invalid Roi. xmin/ymin exceeds xmax/ymax. Roi: " +
+                ToString(roi));
+        }
+
+        if (roi.xmin < 0 || roi.xmax >= shm()->numberOfChannels.x) {
+            throw RuntimeError(
+                "ROI x-dimension outside detector bounds. Roi: " +
+                ToString(roi));
+        }
+
+        if (is2D) {
+            if (roi.ymin < 0 || roi.ymax >= shm()->numberOfChannels.y) {
+                throw RuntimeError(
+                    "ROI y-dimension outside detector bounds. Roi: " +
+                    ToString(roi));
+            }
         } else {
-            // expand complete roi
-            if (moduleRoi.completeRoi()) {
-                moduleRoi.xmin = 0;
-                moduleRoi.xmax = numChansPerMod.x;
-                if (is2D) {
-                    moduleRoi.ymin = 0;
-                    moduleRoi.ymax = numChansPerMod.y;
-                }
-            }
-            LOG(logDEBUG) << iModule << ": " << moduleRoi;
-
-            // get roi at detector level
-            defs::xy pos = calculatePosition(iModule, geometry);
-            defs::ROI moduleFullRoi{};
-            moduleFullRoi.xmin = numChansPerMod.x * pos.x + moduleRoi.xmin;
-            moduleFullRoi.xmax = numChansPerMod.x * pos.x + moduleRoi.xmax;
-            if (is2D) {
-                moduleFullRoi.ymin = numChansPerMod.y * pos.y + moduleRoi.ymin;
-                moduleFullRoi.ymax = numChansPerMod.y * pos.y + moduleRoi.ymax;
-            }
-            LOG(logDEBUG) << iModule << ": (full roi)" << moduleFullRoi;
-
-            // get min and max
-            if (retval.xmin == -1 || moduleFullRoi.xmin < retval.xmin) {
-                LOG(logDEBUG) << iModule << ": xmin updated";
-                retval.xmin = moduleFullRoi.xmin;
-            }
-            if (retval.xmax == -1 || moduleFullRoi.xmax > retval.xmax) {
-                LOG(logDEBUG) << iModule << ": xmax updated";
-                retval.xmax = moduleFullRoi.xmax;
-            }
-            if (retval.ymin == -1 || moduleFullRoi.ymin < retval.ymin) {
-                LOG(logDEBUG) << iModule << ": ymin updated";
-                retval.ymin = moduleFullRoi.ymin;
-            }
-            if (retval.ymax == -1 || moduleFullRoi.ymax > retval.ymax) {
-                LOG(logDEBUG) << iModule << ": ymax updated";
-                retval.ymax = moduleFullRoi.ymax;
+            if ((roi.ymin != -1 && roi.ymin != 0) ||
+                (roi.ymax != -1 && roi.ymax != 0)) {
+                throw RuntimeError(
+                    "Invalid Y range for 1D detector: should be -1. Roi: " +
+                    ToString(roi));
+            }
+        }
+
+        for (size_t j = i + 1; j < rois.size(); ++j) {
+            if (roisOverlap(rois[i], rois[j])) {
+                throw RuntimeError("Invalid Overlapping Rois.");
             }
         }
-        LOG(logDEBUG) << iModule << ": (retval): " << retval;
     }
-    if (retval.ymin == -1) {
-        retval.ymin = 0;
-        retval.ymax = 0;
-    }
-    return retval;
 }
 
-void DetectorImpl::setRxROI(const defs::ROI arg) {
+defs::xy DetectorImpl::calculatePosition(size_t moduleIndex,
+                                         const defs::xy &geometry) const {
+    if ((geometry.x != 0 && geometry.x != 1) ||
+        (geometry.y != 0 && geometry.y != 1)) {
+        throw RuntimeError("Invalid geometry configuration. Geometry: " +
+                           ToString(geometry));
+    }
+
+    if (moduleIndex >= static_cast<size_t>(geometry.x * geometry.y)) {
+        throw RuntimeError("Module index " + std::to_string(moduleIndex) +
+                           " out of bounds.");
+    }
+
+    int x = moduleIndex % geometry.x;
+    int y = moduleIndex / geometry.x;
+    return defs::xy{x, y};
+}
+
+defs::xy DetectorImpl::getPortGeometry() const {
+    defs::xy portGeometry(1, 1);
+    switch (shm()->detType) {
+    case EIGER:
+        portGeometry.x = modules[0]->getNumberofUDPInterfacesFromShm();
+        break;
+    case JUNGFRAU:
+    case MOENCH:
+        portGeometry.y = modules[0]->getNumberofUDPInterfacesFromShm();
+        break;
+    default:
+        break;
+    }
+    return portGeometry;
+}
+
+defs::xy DetectorImpl::calculatePosition(int moduleIndex,
+                                         defs::xy geometry) const {
+    int maxYMods = shm()->numberOfModules.y;
+    int y = (moduleIndex % maxYMods) * geometry.y;
+    int x = (moduleIndex / maxYMods) * geometry.x;
+    return defs::xy{x, y};
+}
+
+defs::ROI DetectorImpl::getModuleROI(int moduleIndex) const {
+    const defs::xy modSize = modules[0]->getNumberOfChannels();
+    // calculate module position (not taking into account port geometry)
+    const defs::xy modPos = calculatePosition(moduleIndex, defs::xy{1, 1});
+    return defs::ROI{modSize.x * modPos.x, modSize.x * (modPos.x + 1) - 1,
+                     modSize.y * modPos.y,
+                     modSize.y * (modPos.y + 1) - 1}; // convert y for 1d?
+}
+
+void DetectorImpl::convertGlobalRoiToPortLevel(
+    const defs::ROI &userRoi, const defs::ROI &moduleRoi,
+    std::vector<std::map<int, defs::ROI>> &portRois) const {
+    const defs::xy modSize = modules[0]->getNumberOfChannels();
+    const defs::xy geometry = getPortGeometry();
+    const int numPorts = geometry.x * geometry.y;
+    if (numPorts > 2) {
+        throw RuntimeError("Only up to 2 ports per module supported.");
+    }
+
+    for (int port = 0; port < numPorts; ++port) {
+        defs::ROI portRoi = moduleRoi;
+        // Calculate port ROI boundaries (split vertically or horizontally)
+        if (geometry.x == 2) {
+            int midX = (moduleRoi.xmin + moduleRoi.xmax) / 2;
+            if (port == 0)
+                portRoi.xmax = midX;
+            else
+                portRoi.xmin = midX + 1;
+        } else if (geometry.y == 2) {
+            int midY = (moduleRoi.ymin + moduleRoi.ymax) / 2;
+            if (port == 0)
+                portRoi.ymax = midY;
+            else
+                portRoi.ymin = midY + 1;
+        }
+
+        // Check if user ROI overlaps with this port ROI
+        if (roisOverlap(userRoi, portRoi)) {
+            defs::ROI clipped{};
+            clipped.xmin = std::max(userRoi.xmin, portRoi.xmin);
+            clipped.xmax = std::min(userRoi.xmax, portRoi.xmax);
+            if (modSize.y > 1) {
+                clipped.ymin = std::max(userRoi.ymin, portRoi.ymin);
+                clipped.ymax = std::min(userRoi.ymax, portRoi.ymax);
+            }
+
+            // Check if port ROI already exists for this port
+            for (const auto &m : portRois) {
+                if (m.find(port) != m.end()) {
+                    throw RuntimeError(
+                        "Multiple ROIs specified for the same port " +
+                        std::to_string(port) +
+                        " with ROI: " + ToString(userRoi));
+                }
+            }
+
+            portRois.push_back({{port, clipped}});
+        }
+    }
+}
+
+void DetectorImpl::setRxROI(const std::vector<defs::ROI> &args) {
     if (shm()->detType == CHIPTESTBOARD ||
         shm()->detType == defs::XILINX_CHIPTESTBOARD) {
         throw RuntimeError("RxRoi not implemented for this Detector");
@@ -1780,118 +1849,37 @@ void DetectorImpl::setRxROI(const defs::ROI arg) {
     if (modules.size() == 0) {
         throw RuntimeError("No Modules added");
     }
-    if (arg.noRoi()) {
-        throw RuntimeError("Invalid Roi of size 0.");
-    }
-    if (arg.completeRoi()) {
-        throw RuntimeError("Did you mean the clear roi command (API: "
-                           "clearRxROI, cmd: rx_clearroi)?");
-    }
-    if (arg.xmin > arg.xmax || arg.ymin > arg.ymax) {
-        throw RuntimeError(
-            "Invalid Receiver Roi. xmin/ymin exceeds xmax/ymax.");
-    }
 
-    defs::xy numChansPerMod = modules[0]->getNumberOfChannels();
-    bool is2D = (numChansPerMod.y > 1 ? true : false);
-    defs::xy geometry = getPortGeometry();
+    validateROIs(args);
 
-    if (!is2D && ((arg.ymin != -1 && arg.ymin != 0) ||
-                  (arg.ymax != -1 && arg.ymax != 0))) {
-        throw RuntimeError(
-            "Invalid Receiver roi. Cannot set 2d roi for a 1d detector.");
-    }
+    for (size_t iModule = 0; iModule < modules.size(); ++iModule) {
+        auto moduleGlobalRoi = getModuleROI(iModule);
 
-    if (arg.xmin < 0 || arg.xmax >= shm()->numberOfChannels.x ||
-        (is2D && (arg.ymin < 0 || arg.ymax >= shm()->numberOfChannels.y))) {
-        throw RuntimeError("Invalid Receiver Roi. Outside detector range.");
-    }
+        // at most 2 rois per module (for each port)
+        std::vector<std::map<int, defs::ROI>> portRois;
 
-    for (size_t iModule = 0; iModule != modules.size(); ++iModule) {
-        // default init = complete roi
-        defs::ROI moduleRoi{};
-
-        // incomplete roi
-        if (!arg.completeRoi()) {
-            // multi module Gotthard2
-            if (shm()->detType == GOTTHARD2 && size() > 1) {
-                moduleRoi.xmin = arg.xmin / 2;
-                moduleRoi.xmax = arg.xmax / 2;
-                if (iModule == 0) {
-                    // all should be even
-                    if (arg.xmin % 2 != 0) {
-                        ++moduleRoi.xmin;
-                    }
-                } else if (iModule == 1) {
-                    // all should be odd
-                    if (arg.xmax % 2 == 0) {
-                        --moduleRoi.xmax;
-                    }
-                } else {
-                    throw RuntimeError("Cannot have more than 2 modules for a "
-                                       "Gotthard2 detector");
-                }
-            } else {
-                // get module limits
-                defs::xy pos = calculatePosition(iModule, geometry);
-                defs::ROI moduleFullRoi{};
-                moduleFullRoi.xmin = numChansPerMod.x * pos.x;
-                moduleFullRoi.xmax = numChansPerMod.x * (pos.x + 1) - 1;
-                if (is2D) {
-                    moduleFullRoi.ymin = numChansPerMod.y * pos.y;
-                    moduleFullRoi.ymax = numChansPerMod.y * (pos.y + 1) - 1;
-                }
-
-                // no roi
-                if (arg.xmin > moduleFullRoi.xmax ||
-                    arg.xmax < moduleFullRoi.xmin ||
-                    (is2D && (arg.ymin > moduleFullRoi.ymax ||
-                              arg.ymax < moduleFullRoi.ymin))) {
-                    moduleRoi.setNoRoi();
-                }
-                // incomplete module roi
-                else if (arg.xmin > moduleFullRoi.xmin ||
-                         arg.xmax < moduleFullRoi.xmax ||
-                         (is2D && (arg.ymin > moduleFullRoi.ymin ||
-                                   arg.ymax < moduleFullRoi.ymax))) {
-                    moduleRoi.xmin = (arg.xmin <= moduleFullRoi.xmin)
-                                         ? 0
-                                         : (arg.xmin % numChansPerMod.x);
-                    moduleRoi.xmax = (arg.xmax >= moduleFullRoi.xmax)
-                                         ? numChansPerMod.x - 1
-                                         : (arg.xmax % numChansPerMod.x);
-                    if (is2D) {
-                        moduleRoi.ymin = (arg.ymin <= moduleFullRoi.ymin)
-                                             ? 0
-                                             : (arg.ymin % numChansPerMod.y);
-                        moduleRoi.ymax = (arg.ymax >= moduleFullRoi.ymax)
-                                             ? numChansPerMod.y - 1
-                                             : (arg.ymax % numChansPerMod.y);
-                    }
-                }
+        for (const auto &arg : args) {
+            if (roisOverlap(arg, moduleGlobalRoi)) {
+                convertGlobalRoiToPortLevel(arg, moduleGlobalRoi, portRois);
             }
         }
-        modules[iModule]->setRxROI(moduleRoi);
-    }
-    // updating shm rx_roi for gui purposes
-    shm()->rx_roi = arg;
-
-    // metadata
-    if (arg.completeRoi()) {
-        modules[0]->setRxROIMetadata(defs::ROI(0, shm()->numberOfChannels.x - 1,
-                                               0,
-                                               shm()->numberOfChannels.y - 1));
-    } else {
-        modules[0]->setRxROIMetadata(arg);
+        // print the rois for debugging
+        LOG(logINFOBLUE) << "Module " << iModule << " RxROIs:";
+        for (const auto &portRoi : portRois) {
+            for (const auto &roi : portRoi) {
+                LOG(logINFOBLUE)
+                    << "  Port " << roi.first << ": " << ToString(roi.second);
+            }
+        }
+        // modules[iModule]->setRxROIs(portRois); TODO
     }
+    rxRoiTemp = args;
 }
 
-void DetectorImpl::clearRxROI() {
-    Parallel(&Module::setRxROI, {}, defs::ROI{});
-    shm()->rx_roi.xmin = -1;
-    shm()->rx_roi.ymin = -1;
-    shm()->rx_roi.xmax = -1;
-    shm()->rx_roi.ymax = -1;
+void DetectorImpl::clearRxROI() { rxRoiTemp.clear(); }
+
+int DetectorImpl::getNumberOfUdpPortsInRxROI() const {
+    return 0; // TODO
 }
 
 void DetectorImpl::getBadChannels(const std::string &fname,

slsDetectorSoftware/src/DetectorImpl.h

@@ -24,7 +24,7 @@ class detectorData;
 class Module;
 
 #define DETECTOR_SHMAPIVERSION 0x190809
-#define DETECTOR_SHMVERSION    0x220505
+#define DETECTOR_SHMVERSION    0x250616
 #define SHORT_STRING_LENGTH    50
 
 /**
@@ -65,8 +65,6 @@ struct sharedDetector {
     bool gapPixels;
     /** high water mark of listening tcp port (only data) */
     int zmqHwm;
-    /** in shm for gui purposes */
-    defs::ROI rx_roi{};
 };
 
 class DetectorImpl : public virtual slsDetectorDefs {
@@ -303,9 +301,11 @@ class DetectorImpl : public virtual slsDetectorDefs {
     std::vector<std::pair<std::string, uint16_t>>
     verifyUniqueRxHost(const std::vector<std::string> &names) const;
 
-    defs::ROI getRxROI() const;
-    void setRxROI(const defs::ROI arg);
+    defs::xy getPortGeometry() const;
+    std::vector<defs::ROI> getRxROI() const;
+    void setRxROI(const std::vector<defs::ROI> &args);
     void clearRxROI();
+    int getNumberOfUdpPortsInRxROI() const;
 
     void getBadChannels(const std::string &fname, Positions pos) const;
     void setBadChannels(const std::string &fname, Positions pos);
@@ -422,12 +422,19 @@ class DetectorImpl : public virtual slsDetectorDefs {
      */
     int kbhit();
 
-    defs::xy getPortGeometry() const;
-    defs::xy calculatePosition(int moduleIndex, defs::xy geometry) const;
-
     void verifyUniqueHost(
         bool isDet, std::vector<std::pair<std::string, uint16_t>> &hosts) const;
 
+    bool roisOverlap(const defs::ROI &a, const defs::ROI &b) const;
+    void validateROIs(const std::vector<defs::ROI> &rois);
+    defs::xy calculatePosition(size_t moduleIndex,
+                               const defs::xy &geometry) const;
+    defs::xy calculatePosition(int moduleIndex, defs::xy geometry) const;
+    defs::ROI getModuleROI(int moduleIndex) const;
+    void convertGlobalRoiToPortLevel(
+        const defs::ROI &userRoi, const defs::ROI &moduleRoi,
+        std::vector<std::map<int, defs::ROI>> &portRois) const;
+
     const int detectorIndex{0};
     SharedMemory<sharedDetector> shm{0, -1};
     SharedMemory<CtbConfig> ctb_shm{0, -1, CtbConfig::shm_tag()};
@@ -455,6 +462,8 @@ class DetectorImpl : public virtual slsDetectorDefs {
 
     void (*dataReady)(detectorData *, uint64_t, uint32_t, void *){nullptr};
     void *pCallbackArg{nullptr};
+
+    std::vector<defs::ROI> rxRoiTemp;
 };
 
 } // namespace sls

slsDetectorSoftware/src/Module.cpp

@@ -1520,7 +1520,7 @@ bool Module::getRxArping() const {
 void Module::setRxArping(bool enable) {
     sendToReceiver(F_SET_RECEIVER_ARPING, static_cast<int>(enable), nullptr);
 }
-
+/*
 defs::ROI Module::getRxROI() const {
     return sendToReceiver<slsDetectorDefs::ROI>(F_RECEIVER_GET_RECEIVER_ROI);
 }
@@ -1533,7 +1533,7 @@ void Module::setRxROI(const slsDetectorDefs::ROI arg) {
 void Module::setRxROIMetadata(const slsDetectorDefs::ROI arg) {
     sendToReceiver(F_RECEIVER_SET_RECEIVER_ROI_METADATA, arg, nullptr);
 }
-
+*/
 // File
 slsDetectorDefs::fileFormat Module::getFileFormat() const {
     return sendToReceiver<fileFormat>(F_GET_RECEIVER_FILE_FORMAT);

slsDetectorSoftware/src/Module.h

@@ -301,9 +301,9 @@ class Module : public virtual slsDetectorDefs {
     std::array<pid_t, NUM_RX_THREAD_IDS> getReceiverThreadIds() const;
     bool getRxArping() const;
     void setRxArping(bool enable);
-    defs::ROI getRxROI() const;
-    void setRxROI(const slsDetectorDefs::ROI arg);
-    void setRxROIMetadata(const slsDetectorDefs::ROI arg);
+    // defs::ROI getRxROI() const;
+    // void setRxROI(const slsDetectorDefs::ROI arg);
+    // void setRxROIMetadata(const slsDetectorDefs::ROI arg);
 
     /**************************************************
      *                                                *

slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp

@@ -466,7 +466,6 @@ TEST_CASE("rx_arping", "[.cmdcall][.rx]") {
         }
     }
 }
-
 TEST_CASE("rx_roi", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
@@ -479,8 +478,7 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
         defs::xy detsize = det.getDetectorSize();
 
         // 1d
-        if (det_type == defs::GOTTHARD || det_type == defs::GOTTHARD2 ||
-            det_type == defs::MYTHEN3) {
+        if (det_type == defs::GOTTHARD2 || det_type == defs::MYTHEN3) {
             {
                 std::ostringstream oss;
                 caller.call("rx_roi", {"5", "10"}, -1, PUT, oss);
@@ -491,11 +489,48 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
                 caller.call("rx_roi", {"10", "15"}, -1, PUT, oss);
                 REQUIRE(oss.str() == "rx_roi [10, 15]\n");
             }
+            REQUIRE_THROWS(caller.call("rx_roi", {"0", "0"}, -1, PUT));
             REQUIRE_THROWS(caller.call("rx_roi", {"-1", "-1"}, -1, PUT));
-            REQUIRE_THROWS(
-                caller.call("rx_roi", {"10", "15", "25", "30"}, -1, PUT));
+            // xmin > xmax
+            REQUIRE_THROWS(caller.call("rx_roi", {"[12, 8, -1, -1]"}, -1, PUT));
+            // outside detector bounds
+            REQUIRE_THROWS(caller.call(
+                "rx_roi",
+                {"[95," + std::to_string(detsize.x + 5) + ", -1, -1]"}, -1,
+                PUT));
+            // module level not allowed
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[5, 10, -1, -1]"}, 0, PUT));
+
+            // vector of rois
+            // square brackets missing
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[5, 20, -1, -1; 25, 30, -1, -1]"}, -1, PUT));
+            // invalid roi, 4 parts expected
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[5, 20, -1]; [25, 30, -1, -1]"}, -1, PUT));
+            // overlapping rois
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[0, 10,-1, -1];[5, 15, -1, -1]"}, -1, PUT));
+
+            if (det.size() == 2) {
+                auto moduleSize = det.getModuleSize()[0];
+                std::string stringMin =  std::to_string(moduleSize.x);
+                std::string stringMax =  std::to_string(moduleSize.x + 1);
+
+                // separated by space is allowed
+                REQUIRE_NOTHROW(caller.call(
+                    "rx_roi", {"[5, 10, -1, -1]", "[" + stringMin + ", " + stringMax + ", -1, -1]"}, -1, PUT));
+                std::ostringstream oss;
+                // separated by semicolon is allowed
+                REQUIRE_NOTHROW(caller.call(
+                    "rx_roi", {"[5, 10, -1, -1];[" + stringMin + ", " + stringMax + ", -1, -1]"}, -1, PUT, oss));
+                REQUIRE(oss.str() ==
+                        "rx_roi [5, 10];[" + stringMin + ", " + stringMax + "]\n");
+
+            }
         }
-        // 2d
+        // 2d eiger, jungfrau, moench
         else {
             {
                 std::ostringstream oss;
@@ -519,8 +554,77 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
                                          std::to_string(detsize.y - 5) +
                                          std::string("]\n"));
             }
+            REQUIRE_THROWS(
+                caller.call("rx_roi", {"0", "0", "0", "0"}, -1, PUT));
             REQUIRE_THROWS(
                 caller.call("rx_roi", {"-1", "-1", "-1", "-1"}, -1, PUT));
+            // xmin > xmax
+            REQUIRE_THROWS(caller.call("rx_roi", {"[12, 8, 0, 10]"}, -1, PUT));
+            // ymin > ymax
+            REQUIRE_THROWS(caller.call("rx_roi", {"[0, 10, 20, 5]"}, -1, PUT));
+            // outside detector bounds
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[95," + std::to_string(detsize.x + 5) + ", 0, 10]"},
+                -1, PUT));
+            REQUIRE_THROWS(caller.call(
+                "rx_roi",
+                {"[95, 100, 0, " + std::to_string(detsize.y + 5) + "]"}, -1,
+                PUT));
+            // module level not allowed
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[5, 10, 20, 30]"}, 0, PUT));
+
+            // vector of rois
+            // square brackets missing
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[5, 20, 20, 30; 25, 30, 14, 15]"}, -1, PUT));
+            // invalid roi, 4 parts expected
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[5, 20, 20]; [25, 30, 14, 15]"}, -1, PUT));
+            // overlapping rois
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[0, 10, 0, 10];[5, 15, 0, 10]"}, -1, PUT));
+            REQUIRE_THROWS(caller.call(
+                "rx_roi", {"[0, 10, 0, 10];[0, 10, 9, 11]"}, -1, PUT));
+
+            auto portSize = det.getPortSize()[0];
+            if (det_type == defs::EIGER) {
+                std::string stringMin =  std::to_string(portSize.x);
+                std::string stringMax =  std::to_string(portSize.x + 1);
+
+                // separated by space is allowed
+                REQUIRE_NOTHROW(caller.call(
+                    "rx_roi", {"[5, 10, 20, 30]", "[" + stringMin + ", " + stringMax + ", 20, 30]"}, -1, PUT));
+                std::ostringstream oss;
+                // separated by semicolon is allowed
+                REQUIRE_NOTHROW(caller.call(
+                    "rx_roi", {"[5, 10, 20, 30];[" + stringMin + ", " + stringMax + ", 20, 30]"}, -1, PUT, oss));
+                REQUIRE(oss.str() ==
+                    "rx_roi [5, 10, 20, 30];[" + stringMin + ", " + stringMax + ", 20, 30]\n");
+            }
+            if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
+                // 2 interfaces or 2 modules
+                if ((det.getNumberofUDPInterfaces().tsquash(
+                        "inconsistent number of interfaces") == 2) || (det.size() == 2)) {
+                    std::string stringMin = std::to_string(portSize.y);
+                    std::string stringMax = std::to_string(portSize.y + 1);
+                    if (det.size() == 2) {
+                        auto moduleSize = det.getModuleSize()[0];
+                        stringMin =  std::to_string(moduleSize.y);
+                        stringMax =  std::to_string(moduleSize.y + 1);
+                    }
+
+                    // separated by space is allowed
+                    REQUIRE_NOTHROW(caller.call(
+                        "rx_roi", {"[5, 10, 20, 30]", "[25, 28, " + stringMin + ", " + stringMax + "]"}, -1, PUT));
+                    std::ostringstream oss;
+                    // separated by semicolon is allowed
+                    REQUIRE_NOTHROW(caller.call(
+                        "rx_roi", {"[5, 10, 20, 30];[25, 28, " + stringMin + ", " +  stringMax + "]"}, -1, PUT, oss));
+                    REQUIRE(oss.str() ==
+                        "rx_roi [5, 10, 20, 30];[25, 28, " + stringMin + ", " +  stringMax + "]\n");
+                }
+            }
         }
 
         for (int i = 0; i != det.size(); ++i) {
@@ -529,6 +633,7 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
     }
 }
 
+
 TEST_CASE("rx_clearroi", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);

slsSupportLib/include/sls/ToString.h

@@ -348,5 +348,23 @@ std::vector<T> StringTo(const std::vector<std::string> &strings) {
         result.push_back(StringTo<T>(s));
     return result;
 }
+/*
+template <typename T>
+std::string ToString(const std::vector<T> &vec) {
+    std::ostringstream oss;
+    oss << "[";
+    for (size_t i = 0; i < vec.size(); ++i) {
+        oss << vec[i];
+        if (i != vec.size() - 1)
+            oss << ", ";
+    }
+    oss << "]";
+    return oss.str();
+}*/
+
+/*template <typename T>
+std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
+    return os << ToString(v);
+}*/
 
 } // namespace sls

slsSupportLib/include/sls/sls_detector_defs.h

@@ -237,7 +237,8 @@ class slsDetectorDefs {
             return (xmin == -1 && xmax == -1 && ymin == -1 && ymax == -1);
         }
         constexpr bool noRoi() const {
-            return (xmin == 0 && xmax == 0 && ymin == 0 && ymax == 0);
+            return ((xmin == 0 && xmax == 0) &&
+                    ((ymin == 0 && ymax == 0) || (ymin == -1 && ymax == -1)));
         }
         void setNoRoi() {
             xmin = 0;