দুটি আয়তক্ষেত্র একে অপরের সাথে ওভারল্যাপ হয় কিনা তা নির্ধারণ করুন?


337

আমি একটি সি ++ প্রোগ্রাম লেখার চেষ্টা করছি যা ব্যবহারকারীর আয়তক্ষেত্রগুলি (2 এবং 5 এর মধ্যে) তৈরি করতে নিম্নলিখিত ইনপুটগুলি গ্রহণ করে: উচ্চতা, প্রস্থ, এক্স-পোস, ওয়াই-পস। এই সমস্ত আয়তক্ষেত্রটি এক্স এবং y অক্ষের সমান্তরালে উপস্থিত থাকবে, এগুলিই তাদের সমস্ত প্রান্তের 0 বা অনন্তের opালু হবে।

আমি এই প্রশ্নে যা উল্লেখ করা হয়েছে তা বাস্তবায়নের চেষ্টা করেছি তবে আমার খুব ভাগ্য হচ্ছে না।

আমার বর্তমান বাস্তবায়ন নিম্নলিখিতগুলি করে:

// Gets all the vertices for Rectangle 1 and stores them in an array -> arrRect1
// point 1 x: arrRect1[0], point 1 y: arrRect1[1] and so on...
// Gets all the vertices for Rectangle 2 and stores them in an array -> arrRect2

// rotated edge of point a, rect 1
int rot_x, rot_y;
rot_x = -arrRect1[3];
rot_y = arrRect1[2];
// point on rotated edge
int pnt_x, pnt_y;
pnt_x = arrRect1[2]; 
pnt_y = arrRect1[3];
// test point, a from rect 2
int tst_x, tst_y;
tst_x = arrRect2[0];
tst_y = arrRect2[1];

int value;
value = (rot_x * (tst_x - pnt_x)) + (rot_y * (tst_y - pnt_y));
cout << "Value: " << value;  

তবে আমি পুরোপুরি নিশ্চিত নই যে (ক) আমি সঠিকভাবে সংযুক্ত অ্যালগরিদমটি প্রয়োগ করেছি, বা যদি আমি এর ব্যাখ্যাটি ঠিক কীভাবে করতে পারি?

কোন পরামর্শ?


3
আমি ভাবব যে আপনার সমস্যার সমাধানটি কোনও গুণকে জড়িত করে না ।
স্কট এভারেনডেন

উত্তর:


708
if (RectA.Left < RectB.Right && RectA.Right > RectB.Left &&
     RectA.Top > RectB.Bottom && RectA.Bottom < RectB.Top ) 

বা, কার্টেসিয়ান স্থানাঙ্ক ব্যবহার করে

(এক্স 1 এর বাম কোর্ড হওয়ার সাথে সাথে এক্স 2 টি ডান কোর্ড, বাম থেকে ডানে এবং ওয়াই 1 শীর্ষে সমন্বিত হবে, এবং ওয়াই 2 হচ্ছে নীচের দিকের কোর্ড, নীচে থেকে শীর্ষে বৃদ্ধি পাচ্ছে - যদি এইভাবে আপনার সমন্বয় ব্যবস্থা না হয় [যেমন বেশিরভাগ কম্পিউটারের রয়েছে Y দিকটি বিপরীত], নীচের তুলনাগুলি অদলবদল করুন ) ...

if (RectA.X1 < RectB.X2 && RectA.X2 > RectB.X1 &&
    RectA.Y1 > RectB.Y2 && RectA.Y2 < RectB.Y1) 

বলুন আপনার কাছে রেক্ট এ এবং রেক্টি বি প্রমাণটি দ্বন্দ্বের দ্বারা। চারটি শর্তের যে কোনও একটি গ্যারান্টি দেয় যে কোনও ওভারল্যাপের অস্তিত্ব থাকতে পারে :

  • Cond1। যদি এ এর ​​বাম প্রান্তটি খ এর ডান প্রান্তের হয় - তবে A হ'ল সম্পূর্ণরূপে বি এর ডানদিকে
  • Cond2। যদি A এর ডান প্রান্তটি B এর বাম প্রান্তের বাম দিকে হয় - তবে A হ'ল সম্পূর্ণ B এর বাম দিকে
  • Cond3। যদি A এর শীর্ষ প্রান্তটি B এর নীচের প্রান্তের নীচে থাকে - তবে A পুরোপুরি B এর নীচে
  • Cond4। যদি এ এর ​​নীচের প্রান্তটি বি এর শীর্ষ প্রান্তের উপরে থাকে, - তবে এ পুরোপুরি বি এর উপরে

সুতরাং নন-ওভারল্যাপের শর্ত

নন-ওভারল্যাপ => কন্ড 1 বা কন্ড 2 বা কন্ড 3 বা কন্ড 4

সুতরাং, ওভারল্যাপের জন্য পর্যাপ্ত শর্তটি বিপরীত।

ওভারল্যাপ => নয় (কন্ড 1 বা কনড 2 বা কনড 3 বা কন্ড 4)

ডি মরগানের আইন বলছে ডি মরগানকে ব্যবহার
Not (A or B or C or D)করার মতোই Not A And Not B And Not C And Not D
, আমাদেরও রয়েছে

কন্ড 1 নয় এবং কন্ড 2 নয় এবং কন্ড 3 নয় এবং কন্ড 4 নয়

এটি সমান:

  • বি এর ডান প্রান্তের বাম প্রান্ত, [ RectA.Left < RectB.Right], এবং
  • খ এর বাম প্রান্তের ডান প্রান্ত থেকে [ RectA.Right > RectB.Left]] এবং
  • এ এর বি এর নীচে উপরে, [ RectA.Top > RectB.Bottom], এবং
  • এ এর নীচে বি এর শীর্ষ নীচে [ RectA.Bottom < RectB.Top]

দ্রষ্টব্য 1 : এটি মোটামুটি সুস্পষ্ট যে একই নীতিটি কোনও পরিমাণে বাড়ানো যেতে পারে।
দ্রষ্টব্য 2 : এটি কেবলমাত্র একটি পিক্সেলের ওভারল্যাপগুলি গণনা করা, <এবং / বা সেই >সীমানাটির একটি <=বা একটিতে পরিবর্তন করতে মোটামুটি স্পষ্ট হওয়া উচিত >=
দ্রষ্টব্য 3 : এই উত্তরটি, কার্টেসিয়ান স্থানাঙ্কগুলি ব্যবহার করার সময় (এক্স, ওয়াই) স্ট্যান্ডার্ড বীজগণিত কার্টেসিয়ান স্থানাঙ্কের উপর ভিত্তি করে (এক্স বাম থেকে ডানে এবং Y নীচে থেকে উপরে বৃদ্ধি করে)। স্পষ্টতই, যেখানে কোনও কম্পিউটার সিস্টেম স্ক্রিনের স্থানাঙ্ককে আলাদাভাবে যান্ত্রিকীকরণ করতে পারে, (যেমন, উপরে থেকে নীচে পর্যন্ত Y বৃদ্ধি করা, বা এক্স ডান থেকে বামে), বাক্য গঠনটি সেই অনুযায়ী / সামঞ্জস্য করা দরকার


489
এটি কেন কাজ করে তা ভিজ্যুয়ালাইজ করতে আপনার যদি খুব কষ্ট হয়, আমি সাইলেন্ট্যাটট / ইনটারেসেকশন এইচটিএমএলে একটি উদাহরণ পৃষ্ঠা তৈরি করেছি যেখানে আপনি চারদিকে আয়তক্ষেত্রগুলি টানতে এবং তুলনাগুলি দেখতে পারেন।
ম্যাথু ক্রামলে

4
আপনি কি মনে করেন না আপনি কঠোর সীমাবদ্ধতাগুলি ব্যবহার করছেন? যদি দুটি আয়তক্ষেত্র একেবারে একে অপরকে ওভারল্যাপ করে দেয় ঠিক তখন? আপনি <=,> = ??
নওশাদ ফারুক

6
আপনার লিঙ্কে এ.ওয়াই 1 <বিওয়াই 2 এবং এ.ওয়াই 2> বিওয়াই 1 এর জন্য @ ম্যাথেজ ক্রামলে, জিটি ও এলটি চিহ্নগুলি বিপরীত হওয়া উচিত নয়?
নিকটি

15
এটিকে কাজ করতে আমাকে শেষ দুটি তুলনায় <এবং> অদলবদল করতে হয়েছিল
ডেটাগ্রাড

17
না, উত্তর হিসাবে বর্ণিত সঠিক। এটি স্ট্যান্ডার্ড কার্তেসিয়ান স্থানাঙ্ক ব্যবহারের ভিত্তিতে তৈরি। আপনি যদি অন্য কোনও সিস্টেম ব্যবহার করেন, (Y শীর্ষে থেকে নীচে বৃদ্ধি পাচ্ছেন), তবে উপযুক্ত সামঞ্জস্য করুন।
চার্লস ব্রেটানা

115
struct rect
{
    int x;
    int y;
    int width;
    int height;
};

bool valueInRange(int value, int min, int max)
{ return (value >= min) && (value <= max); }

bool rectOverlap(rect A, rect B)
{
    bool xOverlap = valueInRange(A.x, B.x, B.x + B.width) ||
                    valueInRange(B.x, A.x, A.x + A.width);

    bool yOverlap = valueInRange(A.y, B.y, B.y + B.height) ||
                    valueInRange(B.y, A.y, A.y + A.height);

    return xOverlap && yOverlap;
}

15
সবচেয়ে সহজ এবং পরিষ্কার উত্তর।
ldog

1
@ ই জেমস আমার অনুমান যে শেষটি B.heightহওয়া উচিতA.height
mat_boy

'মিনিট' এবং 'সর্বাধিক' হ'ল <উইন্ডোজ। আপনি এটি করে #undef minএবং #undef max, বা বিভিন্ন পরামিতি নাম ব্যবহার করে এটি ঠিক করতে পারেন ।
মিচিয়সন

আপনি যদি ব্যাপকভাবে ব্যবহার করেন তবে আপনি মান রেকর্ড করতে পারেন#define BETWEEN(value,min,max) \ (\ value > max ? max : ( value < min ? min : value )\ )
টাটা

@ নেমো প্রকৃতপক্ষে, চেকিং xOverlapএক-মাত্রায় রয়েছে; rectOverlapদ্বিমাত্রিক। এটি লুপ ব্যবহার করে এন মাত্রায় প্রসারিত হতে পারে।
Justme0

27
struct Rect
{
    Rect(int x1, int x2, int y1, int y2)
    : x1(x1), x2(x2), y1(y1), y2(y2)
    {
        assert(x1 < x2);
        assert(y1 < y2);
    }

    int x1, x2, y1, y2;
};

bool
overlap(const Rect &r1, const Rect &r2)
{
    // The rectangles don't overlap if
    // one rectangle's minimum in some dimension 
    // is greater than the other's maximum in
    // that dimension.

    bool noOverlap = r1.x1 > r2.x2 ||
                     r2.x1 > r1.x2 ||
                     r1.y1 > r2.y2 ||
                     r2.y1 > r1.y2;

    return !noOverlap;
}

সুন্দর! ডি মরগানস আইন প্রয়োগ করে প্রাপ্ত হন: r1.x1 <= r2.x2 && r2.x1 <= r1.x2 && r1.y1 <= r2.y2&& r2.y1 <= r1.y2।
বোরঝ

23

কোনও আয়তক্ষেত্রটি অন্যটির বাইরে সম্পূর্ণরূপে আছে কিনা তা পরীক্ষা করা সহজ, তাই যদি এটি হয় তবে

বাম দিকে...

(r1.x + r1.width < r2.x)

বা ডানদিকে ...

(r1.x > r2.x + r2.width)

বা উপরে ...

(r1.y + r1.height < r2.y)

বা নীচে ...

(r1.y > r2.y + r2.height)

দ্বিতীয় আয়তক্ষেত্রের সাথে এটি সম্ভবত এটির সাথে সংঘর্ষ করতে পারে না। সুতরাং এমন একটি ক্রিয়াকলাপের জন্য যা একটি বুলিয়ানকে আবহাওয়ার আয়তক্ষেত্রগুলির সংঘর্ষের আবহাওয়ার কথা বলে, আমরা কেবল শর্তগুলি যৌক্তিক ওআর দ্বারা সংযুক্ত করি এবং ফলাফলটিকে প্রত্যাখ্যান করি:

function checkOverlap(r1, r2) : Boolean
{ 
    return !(r1.x + r1.width < r2.x || r1.y + r1.height < r2.y || r1.x > r2.x + r2.width || r1.y > r2.y + r2.height);
}

কেবলমাত্র স্পর্শ করার সময় ইতিমধ্যে ইতিবাচক ফলাফল পেতে, আমরা "<" এবং ">" "<=" এবং "> =" দ্বারা পরিবর্তন করতে পারি।


3
এবং এটিতে ডি মরগানের আইন প্রয়োগ করুন।
বোরজ

6

নিজেকে বিপরীত প্রশ্ন জিজ্ঞাসা করুন: দুটি আয়তক্ষেত্র একেবারে ছেদ না করলে আমি কীভাবে তা নির্ধারণ করতে পারি? স্পষ্টতই, আয়তক্ষেত্র B এর সম্পূর্ণ বামে একটি আয়তক্ষেত্রটি ছেদ করে না। এছাড়াও যদি পুরোপুরি ডানদিকে থাকে। এবং একইভাবে যদি A সম্পূর্ণরূপে বি এর উপরে বা বি এর সম্পূর্ণ নীচে থাকে তবে অন্য কোনও ক্ষেত্রে এ এবং বি ছেদ করে।

এরপরে কি বাগ থাকতে পারে তবে আমি অ্যালগরিদম সম্পর্কে যথেষ্ট আত্মবিশ্বাসী:

struct Rectangle { int x; int y; int width; int height; };

bool is_left_of(Rectangle const & a, Rectangle const & b) {
   if (a.x + a.width <= b.x) return true;
   return false;
}
bool is_right_of(Rectangle const & a, Rectangle const & b) {
   return is_left_of(b, a);
}

bool not_intersect( Rectangle const & a, Rectangle const & b) {
   if (is_left_of(a, b)) return true;
   if (is_right_of(a, b)) return true;
   // Do the same for top/bottom...
 }

bool intersect(Rectangle const & a, Rectangle const & b) {
  return !not_intersect(a, b);
}

6

মনে করুন যে আপনি এই জাতীয় আয়তক্ষেত্রগুলির অবস্থান এবং আকারগুলি সংজ্ঞায়িত করেছেন:

এখানে চিত্র বর্ণনা লিখুন

আমার সি ++ বাস্তবায়ন এরকম:

class Vector2D
{
    public:
        Vector2D(int x, int y) : x(x), y(y) {}
        ~Vector2D(){}
        int x, y;
};

bool DoRectanglesOverlap(   const Vector2D & Pos1,
                            const Vector2D & Size1,
                            const Vector2D & Pos2,
                            const Vector2D & Size2)
{
    if ((Pos1.x < Pos2.x + Size2.x) &&
        (Pos1.y < Pos2.y + Size2.y) &&
        (Pos2.x < Pos1.x + Size1.x) &&
        (Pos2.y < Pos1.y + Size1.y))
    {
        return true;
    }
    return false;
}

উপরের প্রদত্ত চিত্র অনুসারে একটি ফাংশন কল:

DoRectanglesOverlap(Vector2D(3, 7),
                    Vector2D(8, 5),
                    Vector2D(6, 4),
                    Vector2D(9, 4));

ifব্লকের ভিতরে থাকা তুলনাগুলি নীচের মত দেখতে পাবেন:

if ((Pos1.x < Pos2.x + Size2.x) &&
    (Pos1.y < Pos2.y + Size2.y) &&
    (Pos2.x < Pos1.x + Size1.x) &&
    (Pos2.y < Pos1.y + Size1.y))
                   
if ((   3   <    6   +   9    ) &&
    (   7   <    4   +   4    ) &&
    (   6   <    3   +   8    ) &&
    (   4   <    7   +   5    ))

3

জাভা এপিআইতে এটি কীভাবে হয়েছে তা এখানে দেখুন:

public boolean intersects(Rectangle r) {
    int tw = this.width;
    int th = this.height;
    int rw = r.width;
    int rh = r.height;
    if (rw <= 0 || rh <= 0 || tw <= 0 || th <= 0) {
        return false;
    }
    int tx = this.x;
    int ty = this.y;
    int rx = r.x;
    int ry = r.y;
    rw += rx;
    rh += ry;
    tw += tx;
    th += ty;
    //      overflow || intersect
    return ((rw < rx || rw > tx) &&
            (rh < ry || rh > ty) &&
            (tw < tx || tw > rx) &&
            (th < ty || th > ry));
}

নোট করুন যে সি ++ তে ওভারফ্লোর জন্য সেই পরীক্ষাগুলি কাজ করবে না, কারণ স্বাক্ষরিত পূর্ণসংখ্যা ওভারফ্লো অপরিজ্ঞাত।
বেন ভয়েগট

2

প্রশ্নে, আপনি যখন গণিতগুলিতে আয়তক্ষেত্রগুলি ঘোরার নির্বিচারে কোণে থাকেন তখন তার সাথে আপনি লিঙ্ক করেন। তবে আমি যদি প্রশ্নটির কোণগুলি সম্পর্কে কিছুটা বুঝতে পারি তবে আমি ব্যাখ্যা করি যে সমস্ত আয়তক্ষেত্র একে অপরের লম্ব হয়।

ওভারল্যাপ সূত্রের ক্ষেত্রটি জানা একজন সাধারণ:

উদাহরণ ব্যবহার করে:

   1 2 3 4 5 6

1 + --- + --- +
   | |   
2 + এ + --- + --- +
   | | খ |
3 + + + --- + --- + +
   | | | | |
4 + --- + --- + --- + --- + +
               | |
5 + সি +
               | |
6 + --- + --- +

1) সমস্ত এক্স স্থানাঙ্ক (উভয় বাম এবং ডান) একটি তালিকাতে সংগ্রহ করুন, তারপরে এটি বাছাই করুন এবং নকলগুলি সরিয়ে ফেলুন

1 3 4 5 6

2) সমস্ত y স্থানাঙ্ক (উভয় উপরে এবং নীচে) একটি তালিকাতে সংগ্রহ করুন, তারপরে এটি বাছাই করুন এবং নকলগুলি সরান

1 2 3 4 6

3) অনন্য এক্স কোঅর্ডিনেটের মধ্যে ফাঁক সংখ্যার দ্বারা 2D অ্যারে তৈরি করুন * অনন্য y কোঅর্ডিনেটের মধ্যে ফাঁক সংখ্যা।

4 * 4

4) সমস্ত গ্রন্থে আয়তক্ষেত্রগুলি এই গ্রিডে আঁকুন, এটির উপরের প্রতিটি ঘরের সংখ্যা বাড়িয়ে তোলা:

   1 3 4 5 6

1 + --- +
   | 1 | 0 0 0
2 + --- + --- + --- +
   | 1 | 1 | 1 | 0
3 + --- + --- + --- + --- +
   | 1 | 1 | 2 | 1 |
4 + --- + --- + --- + --- +
     0 0 | 1 | 1 |
6 + --- + --- +

5) আপনি আয়তক্ষেত্রগুলি আঁকলে ওভারল্যাপগুলিকে আটকাতে সহজ inter


2
struct Rect
{
   Rect(int x1, int x2, int y1, int y2)
   : x1(x1), x2(x2), y1(y1), y2(y2)
   {
       assert(x1 < x2);
       assert(y1 < y2);
   }

   int x1, x2, y1, y2;
};

//some area of the r1 overlaps r2
bool overlap(const Rect &r1, const Rect &r2)
{
    return r1.x1 < r2.x2 && r2.x1 < r1.x2 &&
           r1.y1 < r2.y2 && r2.x1 < r1.y2;
}

//either the rectangles overlap or the edges touch
bool touch(const Rect &r1, const Rect &r2)
{
    return r1.x1 <= r2.x2 && r2.x1 <= r1.x2 &&
           r1.y1 <= r2.y2 && r2.x1 <= r1.y2;
}

1

স্থানাঙ্কগুলি যেখানে পিক্সেল রয়েছে তা নির্দেশ করে না think সেগুলি পিক্সেলের মধ্যে বলে মনে করুন। এইভাবে, 2x2 আয়তক্ষেত্রের ক্ষেত্রফল 9 নয়, 4 হওয়া উচিত।

bool bOverlap = !((A.Left >= B.Right || B.Left >= A.Right)
               && (A.Bottom >= B.Top || B.Bottom >= A.Top));

1

সবচেয়ে সহজ উপায়

/**
 * Check if two rectangles collide
 * x_1, y_1, width_1, and height_1 define the boundaries of the first rectangle
 * x_2, y_2, width_2, and height_2 define the boundaries of the second rectangle
 */
boolean rectangle_collision(float x_1, float y_1, float width_1, float height_1, float x_2, float y_2, float width_2, float height_2)
{
  return !(x_1 > x_2+width_2 || x_1+width_1 < x_2 || y_1 > y_2+height_2 || y_1+height_1 < y_2);
}

সবার আগে এটি আপনার মনে রাখুন যে কম্পিউটারগুলিতে স্থানাঙ্ক সিস্টেমটি উল্টো হয়। এক্স-অক্ষ গণিতের মতো একই তবে y- অক্ষগুলি নীচের দিকে বৃদ্ধি পায় এবং উপরের দিকে যেতে কমতে থাকে .. যদি আয়তক্ষেত্রটি কেন্দ্র থেকে আঁকা হয়। যদি x1 স্থানাঙ্কগুলি x2 এর চেয়ে বেশি হয় তবে এর অর্ধেক প্রস্থটি। এর অর্থ অর্ধেক যাওয়া তারা একে অপরকে স্পর্শ করবে। এবং একইভাবে এটির উচ্চতা অর্ধেকের দিকে চলে যাচ্ছে। এটি সংঘর্ষ হবে ..


1

আসুন বলুন যে দুটি আয়তক্ষেত্রটি আয়তক্ষেত্র A এবং আয়তক্ষেত্র বি। তাদের কেন্দ্রগুলি A1 এবং B1 হতে দিন (এ 1 এবং বি 1 এর স্থানাঙ্কগুলি সহজেই খুঁজে পাওয়া যায়), উচ্চতাটি হা এবং এইচবি হতে হবে, প্রস্থটি ওয়া এবং ডাব্লুবিউ হতে দিন, dx হতে দিন A1 এবং B1 এর মধ্যে প্রস্থ (x) দূরত্ব এবং ডাই A1 এবং B1 এর মধ্যে উচ্চতা (y) দূরত্ব হতে পারে।

এখন আমরা বলতে পারি যে আমরা এ এবং বি ওভারল্যাপ বলতে পারি: কখন

if(!(dx > Wa+Wb)||!(dy > Ha+Hb)) returns true

0

আমি একটি সি # সংস্করণ প্রয়োগ করেছি, এটি সহজেই সি ++ এ রূপান্তরিত হয়েছে।

public bool Intersects ( Rectangle rect )
{
  float ulx = Math.Max ( x, rect.x );
  float uly = Math.Max ( y, rect.y );
  float lrx = Math.Min ( x + width, rect.x + rect.width );
  float lry = Math.Min ( y + height, rect.y + rect.height );

  return ulx <= lrx && uly <= lry;
}

2
প্রশিক্ষিত চোখের কাছে এটি স্পষ্ট যে আপনি এটি আয়তক্ষেত্রের জন্য একটি এক্সটেনশন ক্লাস হিসাবে বোঝাতে চেয়েছিলেন তবে আপনি আসলে এটি করার জন্য কোনও বাউন্ডিং বা কোড সরবরাহ করেন নি। যদি আপনি এটি করে থাকেন বা আপনার পদ্ধতিটি কীভাবে ব্যবহার করা হয় তার ব্যাখ্যা দিয়েছিলেন এবং আপনার ভেরিয়েবলগুলির উদ্দেশ্য / উদ্দেশ্য বোঝার জন্য যদি আপনার ভেরিয়েবলগুলি অনুসরণ করে নিম্নলিখিত কারও পক্ষে বর্ণনামূলক পর্যাপ্ত নাম থাকে তবে তা দুর্দান্ত হবে।
tpartee

0

আমার একটি খুব সহজ সমাধান আছে

x1, y1 x2, y2, l1, b1, l2, যথাক্রমে কর্ডিনেট এবং দৈর্ঘ্য এবং প্রস্থ হতে হবে

শর্তটি বিবেচনা করুন ((এক্স 2)

এই আয়তক্ষেত্রটি ওভারল্যাপ করার একমাত্র উপায় যদি বিন্দুটি তির্যকটি x1, y1 অন্য আয়তক্ষেত্রের মধ্যে থাকে বা একইভাবে বিন্দুটি তির্যকটি x2, y2 অন্য আয়তক্ষেত্রের অভ্যন্তরে অবস্থিত হয়। যা উপরের শর্তটি ঠিক বোঝায়।


0

A এবং B দুটি আয়তক্ষেত্র হতে পারে। সি তাদের আবরণ আয়তক্ষেত্র হতে।

four points of A be (xAleft,yAtop),(xAleft,yAbottom),(xAright,yAtop),(xAright,yAbottom)
four points of A be (xBleft,yBtop),(xBleft,yBbottom),(xBright,yBtop),(xBright,yBbottom)

A.width = abs(xAleft-xAright);
A.height = abs(yAleft-yAright);
B.width = abs(xBleft-xBright);
B.height = abs(yBleft-yBright);

C.width = max(xAleft,xAright,xBleft,xBright)-min(xAleft,xAright,xBleft,xBright);
C.height = max(yAtop,yAbottom,yBtop,yBbottom)-min(yAtop,yAbottom,yBtop,yBbottom);

A and B does not overlap if
(C.width >= A.width + B.width )
OR
(C.height >= A.height + B.height) 

এটি সম্ভাব্য সমস্ত ক্ষেত্রে যত্ন নেয়।


0

এটি জাভা প্রোগ্রামিং-বিস্তৃত সংস্করণ পরিচিতির বইটি থেকে অনুশীলন ৩.২৮ কোডটি দুটি পরীক্ষা করে আয়তক্ষেত্রগুলি indentical কিনা তা পরীক্ষা করে, একটি অন্যের ভিতরে রয়েছে এবং একটি অপরটির বাইরে রয়েছে কিনা tests যদি এই শর্তটির কোনওটি পূরণ না হয় তবে দুটি ওভারল্যাপ হয়।

** ৩.২৮ (জ্যামিতি: দুটি আয়তক্ষেত্র) এমন একটি প্রোগ্রাম লিখুন যা ব্যবহারকারীকে দুটি আয়তক্ষেত্রের x-, y- স্থানাঙ্ক, প্রস্থ এবং উচ্চতায় প্রবেশ করতে অনুরোধ করবে এবং দ্বিতীয় আয়তক্ষেত্রটি প্রথমটির অভ্যন্তরে রয়েছে কিনা বা প্রথমটির সাথে ওভারল্যাপ হবে কিনা তা নির্ধারণ করে চিত্র 3.9-তে প্রদর্শিত হয়েছে সমস্ত মামলা কভার করার জন্য আপনার প্রোগ্রামটি পরীক্ষা করুন। নমুনা রান এখানে:

R1 এর কেন্দ্র x-, y- স্থানাঙ্ক, প্রস্থ এবং উচ্চতা লিখুন: 2.5 4 2.5 43 r2 এর কেন্দ্র x-, y- স্থানাঙ্ক, প্রস্থ এবং উচ্চতা লিখুন: 1.5 5 0.5 3 r2 r1 এর অভ্যন্তরে রয়েছে

R1 এর কেন্দ্র x-, y- স্থানাঙ্ক, প্রস্থ এবং উচ্চতা লিখুন: 1 2 3 5.5 r2 এর কেন্দ্র x-, y- স্থানাঙ্ক, প্রস্থ এবং উচ্চতা লিখুন: 3 4 4.5 5 r2 ওভারল্যাপ r1

R1 এর কেন্দ্র x-, y- স্থানাঙ্ক, প্রস্থ এবং উচ্চতা লিখুন: 1 2 3 3 r2 এর কেন্দ্র x-, y- স্থানাঙ্ক, প্রস্থ এবং উচ্চতা লিখুন: 40 45 3 2 r2 আর 1 দিয়ে ওভারল্যাপ করে না

import java.util.Scanner;

public class ProgrammingEx3_28 {
public static void main(String[] args) {
    Scanner input = new Scanner(System.in);

    System.out
            .print("Enter r1's center x-, y-coordinates, width, and height:");
    double x1 = input.nextDouble();
    double y1 = input.nextDouble();
    double w1 = input.nextDouble();
    double h1 = input.nextDouble();
    w1 = w1 / 2;
    h1 = h1 / 2;
    System.out
            .print("Enter r2's center x-, y-coordinates, width, and height:");
    double x2 = input.nextDouble();
    double y2 = input.nextDouble();
    double w2 = input.nextDouble();
    double h2 = input.nextDouble();
    w2 = w2 / 2;
    h2 = h2 / 2;

    // Calculating range of r1 and r2
    double x1max = x1 + w1;
    double y1max = y1 + h1;
    double x1min = x1 - w1;
    double y1min = y1 - h1;
    double x2max = x2 + w2;
    double y2max = y2 + h2;
    double x2min = x2 - w2;
    double y2min = y2 - h2;

    if (x1max == x2max && x1min == x2min && y1max == y2max
            && y1min == y2min) {
        // Check if the two are identicle
        System.out.print("r1 and r2 are indentical");

    } else if (x1max <= x2max && x1min >= x2min && y1max <= y2max
            && y1min >= y2min) {
        // Check if r1 is in r2
        System.out.print("r1 is inside r2");
    } else if (x2max <= x1max && x2min >= x1min && y2max <= y1max
            && y2min >= y1min) {
        // Check if r2 is in r1
        System.out.print("r2 is inside r1");
    } else if (x1max < x2min || x1min > x2max || y1max < y2min
            || y2min > y1max) {
        // Check if the two overlap
        System.out.print("r2 does not overlaps r1");
    } else {
        System.out.print("r2 overlaps r1");
    }

}
}

0
bool Square::IsOverlappig(Square &other)
{
    bool result1 = other.x >= x && other.y >= y && other.x <= (x + width) && other.y <= (y + height); // other's top left falls within this area
    bool result2 = other.x >= x && other.y <= y && other.x <= (x + width) && (other.y + other.height) <= (y + height); // other's bottom left falls within this area
    bool result3 = other.x <= x && other.y >= y && (other.x + other.width) <= (x + width) && other.y <= (y + height); // other's top right falls within this area
    bool result4 = other.x <= x && other.y <= y && (other.x + other.width) >= x && (other.y + other.height) >= y; // other's bottom right falls within this area
    return result1 | result2 | result3 | result4;
}

0

আপনারা যারা তাদের কেন্দ্রিয় পয়েন্ট এবং অর্ধেক মাপগুলি তাদের আয়তক্ষেত্রের ডেটার জন্য ব্যবহার করছেন, সাধারণ x, y, w, h, বা x0, y0, x1, x1 এর পরিবর্তে আপনি কীভাবে এটি করতে পারেন তা এখানে:

#include <cmath> // for fabsf(float)

struct Rectangle
{
    float centerX, centerY, halfWidth, halfHeight;
};

bool isRectangleOverlapping(const Rectangle &a, const Rectangle &b)
{
    return (fabsf(a.centerX - b.centerX) <= (a.halfWidth + b.halfWidth)) &&
           (fabsf(a.centerY - b.centerY) <= (a.halfHeight + b.halfHeight)); 
}

0
struct point { int x, y; };

struct rect { point tl, br; }; // top left and bottom right points

// return true if rectangles overlap
bool overlap(const rect &a, const rect &b)
{
    return a.tl.x <= b.br.x && a.br.x >= b.tl.x && 
           a.tl.y >= b.br.y && a.br.y <= b.tl.y;
}

0

যদি আয়তক্ষেত্রগুলি ওভারল্যাপ হয় তবে ওভারল্যাপের ক্ষেত্রটি শূন্যের চেয়ে বেশি হবে। এখন আসুন ওভারল্যাপ অঞ্চলটি সন্ধান করুন:

যদি তারা ওভারল্যাপ করে তবে ওভারল্যাপ-রেক্টরের বাম প্রান্তটি হবে max(r1.x1, r2.x1)এবং ডান প্রান্তটি হবে min(r1.x2, r2.x2)। সুতরাং ওভারল্যাপের দৈর্ঘ্য হবেmin(r1.x2, r2.x2) - max(r1.x1, r2.x1)

সুতরাং এলাকাটি হবে:

area = (max(r1.x1, r2.x1) - min(r1.x2, r2.x2)) * (max(r1.y1, r2.y1) - min(r1.y2, r2.y2))

তাহলে area = 0তখন তারা ওভারল্যাপ না।

সরল তাই না?


3
এটি ওভারল্যাপের জন্য কাজ করে (যা প্রশ্ন) তবে ছেদ করার জন্য কাজ করবে না, যেহেতু তারা ঠিক কোন কোণে ছেদ করলে এটি কাজ করবে না।
ল্যান্স রবার্টস

আমি এই কোডটি চেষ্টা করেছিলাম এবং এটি মোটেই কার্যকর হয় না। তারা মোটেও ওভারল্যাপ না করলেও আমি ইতিবাচক সংখ্যাগুলি পাচ্ছি।
ব্রেট

@ ব্রেট: হ্যাঁ, কারণ দুটি নেতিবাচক সংখ্যার পণ্যটি ইতিবাচক।
বেন ভয়েগট

@ বেনওয়েগ্ট, সমস্যাটি ছিল যে কোনও ওভারল্যাপ না থাকলে ফাংশনটি 0 ফিরে আসেনি। আমি আমার মন্তব্যে খুব অস্পষ্ট ছিলাম, তবে হ্যাঁ, আমি এই ফাংশনটি থেকে কেবল কখনও অঞ্চল> 0 পেয়েছি।
ব্রেট

আপনি যদি ভাসমান পয়েন্ট সংখ্যাগুলির সাথে কাজ করছেন তবে সাধারণত কোনও সংখ্যার তুলনার আগে বিয়োগ এবং অন্যান্য গাণিতিক জিনিসগুলি ব্যবহার করা খুব খারাপ ধারণা। বিশেষত আপনার যদি একটি সঠিক মানের সাথে তুলনা করতে হয় - এই ক্ষেত্রে শূন্য। এটি তত্ত্বে কাজ করে, তবে বাস্তবে নয়।
মাজা

-1

"আপনি যদি প্রতিটি আয়তক্ষেত্রের মুখোমুখি দুটি এর উল্লম্বের সাথে মিল রেখে বিয়োগফল x বা y স্থানাঙ্ক সম্পাদন করেন, ফলাফলগুলি যদি একই চিহ্ন হয়, তবে দুটি আয়তক্ষেত্র অক্ষকে ওভারল্যাপ করে না" (আমি দুঃখিত, আমি নিশ্চিত না যে আমার অনুবাদটি সঠিক )

এখানে চিত্র বর্ণনা লিখুন

সূত্র: http://www.ieev.org/2009/05/kiem-tra-hai-hinh-chu-nhat-chong-nhau.html


-1

জাভা কোডগুলি সনাক্ত করার জন্য যে আয়তক্ষেত্রগুলি একে অপরের সাথে যোগাযোগ করছে বা ওভারল্যাপ করছে

...

for ( int i = 0; i < n; i++ ) {
    for ( int j = 0; j < n; j++ ) {
        if ( i != j ) {
            Rectangle rectangle1 = rectangles.get(i);
            Rectangle rectangle2 = rectangles.get(j);

            int l1 = rectangle1.l; //left
            int r1 = rectangle1.r; //right
            int b1 = rectangle1.b; //bottom
            int t1 = rectangle1.t; //top

            int l2 = rectangle2.l;
            int r2 = rectangle2.r;
            int b2 = rectangle2.b;
            int t2 = rectangle2.t;

            boolean topOnBottom = t2 == b1;
            boolean bottomOnTop = b2 == t1;
            boolean topOrBottomContact = topOnBottom || bottomOnTop;

            boolean rightOnLeft = r2 == l1;
            boolean leftOnRight = l2 == r1;
            boolean rightOrLeftContact = leftOnRight || rightOnLeft;

            boolean leftPoll = l2 <= l1 && r2 >= l1;
            boolean rightPoll = l2 <= r1 && r2 >= r1;
            boolean leftRightInside = l2 >= l1 && r2 <= r1;
            boolean leftRightPossiblePlaces = leftPoll || rightPoll || leftRightInside;

            boolean bottomPoll = t2 >= b1 && b2 <= b1;
            boolean topPoll = b2 <= b1 && t2 >= b1;
            boolean topBottomInside = b2 >= b1 && t2 <= t1;
            boolean topBottomPossiblePlaces = bottomPoll || topPoll || topBottomInside;


            boolean topInBetween = t2 > b1 && t2 < t1;
            boolean bottomInBetween = b2 > b1 && b2 < t1;
            boolean topBottomInBetween = topInBetween || bottomInBetween;

            boolean leftInBetween = l2 > l1 && l2 < r1;
            boolean rightInBetween = r2 > l1 && r2 < r1;
            boolean leftRightInBetween = leftInBetween || rightInBetween;

            if ( (topOrBottomContact && leftRightPossiblePlaces) || (rightOrLeftContact && topBottomPossiblePlaces) ) {
                path[i][j] = true;
            }
        }
    }
}

...

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.