الخطوة int (SearchDir searchDir)
{
 إرجاع static\_cast(searchDir);
}

std::string DirectionName(SearchDir searchDir)
{
 التبديل (سيرتشدير) ​​{
 حالة البحثDir::قريب:
 إرجاع "DIRECTION\_NEAR";
 حالة SearchDir::بعيد:
 إرجاع "DIRECTION\_FAR";
 حالة SearchDir::لا شيء:
 إرجاع "DIRECTION\_NONE";
 }

 tt\_unreachable();
}

printGridRegion (محصول الشبكة\_section، مستوى int =3)
{
 focus\_logger\_debug\_print(level، "منطقة الشبكة: x،y (%2d، %2d)، wxh %2dx%2d ->الحجم (%2d)\n"،
 Crop.x، Crop.y، Crop.width، Crop.height، Crop.width\*crop.height);
}

printGridRegions باطلة (const std::vector & Cros، مستوى int = 3)
{
 focus\_logger\_debug\_print(level, "Grid Regions, # = %zu\n"، Cros.size());
 لـ (size\_t i = 0; i < Cros.size(); i ++)
 printGridRegion(crops[i],level);
}

الشبكة\_section fullSensor()
{
 return {.x = 0, .y = 0, .width = focusstat\_get\_grid\_width(), .height = focusstat\_get\_grid\_height()};
}

const float CropPosChangeThresholdForRefocus = 0.1; // TODO: يجب ضبط القيمة جيدًا وفقًا للاختبار الحقيقي
bool CropIsSimilar (const Grid\_section & a، const Grid\_section & b، float relativPosChangeLimit)
{
 تعويم نسبيX1Change = std::abs(a.x - b.x) / (تعويم) AAA\_GRID\_WIDTH;
 تعويم نسبيY1Change = std::abs(a.y - b.y) / (float) AAA\_GRID\_HEIGHT;
 float نسبيX2Change = std::abs(a.x + a.width - (b.x + b.width)) / (float) AAA\_GRID\_WIDTH;
 تعويم نسبيY2Change = std::abs(a.y + a.height - (b.y + b.height)) / (float) AAA\_GRID\_HEIGHT;

 focus\_logger\_debug\_print(2, "%s : تغيير موضع الاقتصاص النسبي x1:%f y1:%f وx2:%f y2:%f\n",
 \_\_func\_\_، النسبي X1 التغيير، النسبي 1 التغيير، النسبي X2 التغيير، النسبي 2 التغيير)؛

 إرجاع نسبيX1Change <= relativPosChangeLimit &&
 RelativPosChangeLimit <= relativPosChangeLimit &&
 RelativPosChangeLimit <= relativPosChangeLimit &&
 نسبيًاY2Change <= relativPosChangeLimit;
}

bool CropIsSame(const FocusCrop & a, const FocusCrop & b)
{
 إرجاع CropIsSimilar(a.statsRegion, b.statsRegion, 0);
}

شبكة\_قسم getUpperCropHalf(شبكة ثابتة\_قسم وشبكة)
{
 العودة {.x = الشبكة.x، .y = الشبكة.y، .width = الشبكة. العرض، .height = الشبكة.height/2}؛
}

int motorGetPos(const std::string & name)
{
 int fd = ceres\_motor\_open(name.c\_str());
 إذا (فد < 0) {
 focus\_logger\_debug\_print(1, "غير قادر على فتح المحرك %s!\n"، name.c\_str());
 العودة 0؛
 }
 نقطة البيع.
 ceres\_motor\_get\_pos(fd, &pos);
 سيريس_موتور_كلوز(fd);
 عودة نقاط البيع.
}

باطلة motorSetPos (const std::string & name، int & pos)
{
 int fd = ceres\_motor\_open(name.c\_str());
 إذا (فد < 0) {
 focus\_logger\_debug\_print(1, "غير قادر على فتح المحرك %s!\n"، name.c\_str());
 يعود؛
 }
 إنت مينبوس؛
 كثافة العمليات ماكسبوس؛
 ceres\_motor\_get\_range(fd, &minPos, &maxPos);
 pos = std::clamp(pos, minPos, maxPos);
 ceres_motor_goto_pos(fd, pos);
 سيريس_موتور_كلوز(fd);
}

/\* توضيح الأوضاع الأفقية وأحجام الرويس:
 1 2 3 4 5 6 7
012345678901234567890123456789012345678901234567890123456789012345678901234567
-------------------------------------------------- ----------------------------
 --------------
 -------------
 -------------
 -------------
 -------------
 -------------
 -------------
 --------------
\*/
الأمراض المنقولة جنسيا :: ناقلات الاستشعارRois ()
{
 std::vector roiOnSensor;
 roiOnSensor.push\_back({10, 16, 14, 8});
 roiOnSensor.push\_back({17, 16, 13, 8});
 roiOnSensor.push\_back({23, 16, 13, 8});
 roiOnSensor.push\_back({29, 16, 13, 8});
 roiOnSensor.push\_back({35, 16, 13, 8});
 roiOnSensor.push\_back({41, 16, 13, 8});
 roiOnSensor.push\_back({47, 16, 13, 8});
 roiOnSensor.push\_back({53, 16, 14, 8});

 roiOnSensor.push\_back({10, 20, 14, 8});
 roiOnSensor.push\_back({17, 20, 13, 8});
 roiOnSensor.push\_back({23, 20, 13, 8});
 roiOnSensor.push\_back({29, 20, 13, 8});
 roiOnSensor.push\_back({35, 20, 13, 8});
 roiOnSensor.push\_back({41, 20, 13, 8});
 roiOnSensor.push\_back({47, 20, 13, 8});
 roiOnSensor.push\_back({53, 20, 14, 8});

 roiOnSensor.push\_back({10, 24, 14, 8});
 roiOnSensor.push\_back({17, 24, 13, 8});
 roiOnSensor.push\_back({23, 24, 13, 8});
 roiOnSensor.push\_back({29, 24, 13, 8});
 roiOnSensor.push\_back({35, 24, 13, 8});
 roiOnSensor.push\_back({41, 24, 13, 8});
 roiOnSensor.push\_back({47, 24, 13, 8});
 roiOnSensor.push\_back({53, 24, 14, 8});

 roiOnSensor.push\_back({0, 0, AAA\_GRID\_WIDTH, AAA\_GRID\_HEIGHT});

 إرجاع roiOnSensor;
}

الشبكة\_section placeRoiInCrop(grid\_section المحاصيل، الشبكة\_section roiOnSensor)
{
 // تبسيط بسيط، مع تجاهل AAA\_GRID\_PIX\_OFST
 تعويم تطبيع\_x = ثابت\_cast(roiOnSensor.x) / AAA\_GRID\_WIDTH;
 تعويم تطبيع\_y = ثابت\_cast(roiOnSensor.y) / AAA\_GRID\_HEIGHT;
 تعويم تطبيع\_العرض = ثابت\_cast(roiOnSensor.width) / AAA\_GRID\_WIDTH;
 تعويم طبيعي\_height = static\_cast(roiOnSensor.height) / AAA\_GRID\_HEIGHT;

 // حساب المواضع بالنسبة للمحصول، لذا فإن (0، 0) في أعلى اليسار داخل المحصول
 int start\_x = std::round(crop.width \*normalized\_x);
 int start\_y = std::round(crop.height \*normalized\_y);
 // "النهاية" هي ماض واحد
 int end\_x = std::round(crop.width \* (normalized\_x +normalized\_width));
 int end\_y = std::round(crop.height \* (normalized\_y +normalized\_height));

 // الحساب بالنسبة للمستشعر، والتثبيت داخل المستشعر
 start\_x = std::clamp(start\_x + Crop.x, 0, AAA\_GRID\_WIDTH - 1);
 start\_y = std::clamp(start\_y + Crop.y, 0, AAA\_GRID\_HEIGHT - 1);
 end\_x = std::clamp(end\_x + Crop.x, 1, AAA\_GRID\_WIDTH);
 end\_y = std::clamp(end\_y + Crop.y, 1, AAA\_GRID\_HEIGHT);

 العودة { .x = start\_x، .y = start\_y، .width = end\_x - start\_x، .height = end\_y - start\_y}؛
}

تطبيق باطلةFixeNbOfRoiInCrop (محصول الشبكة\_section، std::vector وroiOnSensor)
{
 std::vector roi\_pattern\_on\_sensor = SensorRois();

 printGridRegions(roi\_pattern\_on\_sensor, 2);

 for (size\_t i = 0; i < roi\_pattern\_on\_sensor.size(); i++) {
 roiOnSensor.push\_back(placeRoiInCrop(crop, roi\_pattern\_on\_sensor[i]));
 }
}

باطل ApplyOneRoiInCrop(grid\_section Crop, std::vector & roiOnSensor)
{
 int Skiped\_hor\_border = Crop.height /10; // للتركيز تجاهل منطقة 10% حول المحصول
 int Skiped\_ver\_border = Crop.width /10;

 roiOnSensor.push\_back({
 .x = المحاصيل.x + تخطي\_ver\_border،
 .y = Crop.y + تخطي\_hor\_border،
 .width = Crop.width - 2\*تخطي\_ver\_border ,
 .height = Crop.height - 2\*skipped\_hor\_border});
}

الأمراض المنقولة جنسيا::ناقل getRoiInSensor (شبكة ثابتة\_قسم واقتصاص)
{
 std::vector roiOnSensor;

 // بالنسبة إلى الإطارات التي يتم اقتصاصها أصغر من الحجم الناتج لعامل تكبير مسار السماعة الأقصى،
 إذا (crop.width < AAA\_GRID\_WIDTH / 2.7){
 focus\_logger\_debug\_print(1, "تحقيق عائد استثمار كبير للتركيز\n");
 ApplyOneRoiInCrop(crop, roiOnSensor);
 ApplyOneRoiInCrop(fullSensor(), roiOnSensor);
 }
 آخر{
 focus\_logger\_debug\_print(1, "ابحث عن عائد استثمار كبير الحجم قابل للتكيف\n");
 ApplyFixeNbOfRoiInCrop(crop, roiOnSensor);
 }
 focus\_logger\_debug\_print(1, "عدد خلايا التركيز في الاقتصاص: %d\n"، static\_cast(roiOnSensor.size()));
 printGridRegions(roiOnSensor, 2);

 إرجاع roiOnSensor;
}

void getRegionFocusValues(uint32\_t \* focusValues, const std::vector & roiOnSensor, عدسة غير موقعة)
{
 لـ (size\_t i = 0; i < roiOnSensor.size(); i++) {
 Grid\_section roi\_on\_crop = roiOnSensor[i];
 بيانات التركيز\_sum;
 focusstat\_get\_average(&roi\_on\_crop, &data\_sum);
 focusValues[i] = data\_sum.sensor[lens].low\_res;
 }
}

عدد المسافات العائمة (الثابت std::المتجه والمحاصيل)
{
 int numDist = 0;
 لـ (const auto & c: المحاصيل) {
 numDist += c.distances.size();
 }
 إرجاع numDist;
}

تعويم متوسط ​​المسافة (الثابت std::vector والمحاصيل)
{
 تعويم مجموع = 0.0؛
 int numDist = 0;

 // focus\_logger\_debug\_print(1, "%s, Cros: %zu\n", \_\_func\_\_, Cros.size());

 لـ (const auto & c: المحاصيل) {
 sumDist = std::تراكم(c.distances.begin(), c.distances.end(), sumDist);
 numDist += c.distances.size();
 }

 إذا (numDist == 0) {
 العودة 0.0؛
 }
 آخر {
 إرجاع sumDist / numDist؛
 }
}

تعويم أقرب مسافة (const FocusCrop & Crop)
{
 إذا (crop.distances.empty())
 العودة 0؛
 آخر
 return \*std::min\_element(crop.distances.begin(), Crop.distances.end());
}

FocusCrop furthestCrop(const std::vector والمحاصيل)
{
 تأكيد(!crops.empty());

 إذا (numDistances(المحاصيل) == 0) {
 // لا ينبغي أن يحدث في حالة الإطارات
 إرجاع المحاصيل.
 }
 آخر {
 std::vector أبعد عن PerCrop؛
 لـ (const auto & c: المحاصيل) {
 furthestPerCrop.push\_back(\*std::max\_element(c.distances.begin(), c.distances.end()));
 }

 أبعد تلقائي = std::max\_element(furthestPerCrop.begin(), furthestPerCrop.end());
 size\_t furthestIndex = الأبعد - الأبعدPerCrop.begin();

 إرجاع المحاصيل[furthestIndex];
 }
}

تطفو على مسافة أبعد (الثابت std::vector والمحاصيل)
{
 إذا (numDistances(المحاصيل) == 0)
 // لا ينبغي أن يحدث في حالة الإطارات، وهذا هو الحال
 العودة 0؛
 آخر {
 std::vector أبعد عن PerCrop؛
 لـ (const auto & c: المحاصيل)
 furthestPerCrop.push\_back(\*std::max\_element(c.distances.begin(), c.distances.end()));
 return \*std::max\_element(furthestPerCrop.begin(), furthestPerCrop.end());
 }
}

إعادة بناء
{"source": "ewof/sharegpt-instruct-unfiltered-deduped", "kind": "human", "evolved_from": null}