check equirectangular photo connected ?

@ShaikhAneesa

Hi there, I have carefully reviewed your project requirements for developing a Python-based workflow to confirm if equirectangular photos were shot from the same angle. I understand the need to check connectivity, calculate scale ratio, angle yaw and pitch, and assign a reliability score to the assessment. Let's chat and discuss it further. To handle your project, I will start with analyzing the metadata of the selected images using OpenCV and NumPy. By extracting key features and comparing them, I will determine the angle and scale ratio between the pair. Additionally, I will implement a confidence scoring system based on the similarity of features. The deliverables will include a detailed text report outlining the connectivity, scale ratio, angle yaw, and confidence score for each image pair. Before signing-off my bid, I would like to ask a question, i.e., how do you plan to use the results of this analysis? Warm Regards, Aneesa.

@sajjadtaghvaeifr

Hello, I trust you're doing well. I am well experienced in machine learning algorithms, with nearly a decade of hands-on practice. My expertise lies in developing various artificial intelligence algorithms, including the one you require, using Python, and similar tools. I have worked with pytorch, and tensorflow to develop DL models, .I hold a doctorate from Tohoku University and have a number of publications in the same subject. My portfolio, which showcases my past work, is available for your review. Your project piqued my interest, and I would be delighted to be part of it. Let's connect to discuss in detail. Warm regards. please check my portfolio link: https://www.freelancer.com/u/sajjadtaghvaeifr

@PINESCRIPTERR

Hi, I can build a Python CLI that compares any selected pair of equirectangular images and returns structured JSON containing: - Same-viewpoint decision - Connected/overlapping decision - Estimated scale ratio - Relative yaw and pitch - Confidence score and supporting metrics I’ll use spherical-aware matching rather than treating panoramas as ordinary flat images. The workflow can project the panorama into cube or perspective faces, detect SIFT/AKAZE features, perform bidirectional descriptor matching, and estimate relative geometry with RANSAC. Confidence will combine verified inlier count, inlier ratio, reprojection error, spatial coverage, rotation consistency, and match ambiguity. Exposure normalisation and robust descriptors will help tolerate lighting differences and stitching artefacts. The dataset will be divided into positive and negative pairs to measure precision, recall, false-positive rate, and angular error. Please note that scale is only reliably defined when the camera geometry and scene provide sufficient overlap; strong parallax or different camera centres can make one global scale ratio invalid. Three technical questions: 1. Does “connected” mean visual overlap, identical camera position, or sequential panorama navigation? 2. Are the panoramas captured with the same camera, resolution, and focal configuration? 3. Do you have labelled matching and non-matching pairs for accuracy validation? Best regards, Houssame

@ImranAli01

Hi there, I went through your project description and understand you need a Python CLI workflow that will compare two equirectangular panoramas, determine whether they share the same viewpoint, estimate their connection, scale ratio, yaw and pitch, and return a reliability score in structured text or JSON. I will build the matching pipeline using OpenCV, NumPy, and appropriate feature or geometric methods, with panorama-aware handling for equirectangular distortion. I will account for lighting and exposure changes, stitching artefacts, and minor image differences while avoiding false matches. The CLI will accept two image paths and produce concise JSON containing the connection decision, estimated scale, yaw, pitch, confidence, and supporting metrics. I will also create a repeatable evaluation workflow using your sample dataset, measuring precision, false-positive/false-negative rates, and matching consistency so the approach can be objectively validated. Installation will remain straightforward through pip or conda, with clear usage documentation. Could you share a few representative sample panoramas here so I can assess their stitching characteristics and choose the most reliable matching strategy? I will share a project blueprint within 24–48 hours of award and begin with the dataset and geometry assessment. Kind Regards, Imran Ali

@hirujiyu

⭕Experienced PYTHON developer since 7+ years ⭕ Hi there, ✔️Based on your requirements, I can build your Python CLI tool to compare two equirectangular images and determine whether they represent the same viewpoint, with reliable geometric verification. Core Features ✦ Same-angle / connection detection ✦ Yaw, pitch & scale ratio calculation ✦ Confidence / reliability score ✦ Robust against lighting, exposure & stitching changes ✦ JSON + concise text report ✦ Repeatable accuracy benchmarking on your dataset ❓ Do you have ground-truth pairs available for measuring accuracy? ❓ What angular tolerance should be considered a “same angle” match? ⚡ I’ll focus on accurate geometric matching rather than simple image similarity, with a clean CLI workflow and easy installation. Looking forward to discussing the approach with you. Thank you.

@mayankinnovative

Hi, As per my understanding: You need a Python CLI tool that takes two equirectangular panoramas, determines whether they were shot from the same viewpoint or are spatially connected, calculates scale ratio and relative yaw/pitch offset between them, assigns a confidence score to the assessment, and outputs a structured plain-text or JSON report, robust against lighting shifts and minor stitching artifacts. Implementation approach: Since equirectangular images distort features non-linearly by latitude, I would first convert regions of interest to a tangent-plane projection before running feature matching, rather than matching directly on the raw equirectangular image, since that distortion is exactly what causes false positives near the poles if ignored. I would use SIFT or ORB for keypoint detection combined with RANSAC-filtered homography estimation, since RANSAC's outlier rejection is what gives tolerance against lighting changes and stitching noise you mentioned rather than assuming clean matches. Yaw and pitch offset I would derive from the estimated relative rotation matrix once matched keypoints are triangulated in spherical coordinates, not from pixel offset alone, since equirectangular pixel shift does not map linearly to angular rotation. The confidence score I would base on inlier ratio and match count together, not either alone, since a small but highly consistent match set can be more reliable than a large noisy one.

@mayr81

I can build a robust Python/CLI workflow to compare any two equirectangular images and determine whether they come from the same camera/view angle, even under lighting/exposure variation and minor stitching artifacts. Approach (high level): - Read panoramas and run feature-based matching on the spherical projection (equirectangular → spherical/UTM mapping) using OpenCV (e.g., SIFT/ORB or equivalents) with illumination-tolerant preprocessing. - Estimate the relative rotation between views (yaw/pitch) via spherical geometry and homography/pose fitting adapted to panoramas. - Determine whether the images are “connected” using geometric consistency checks (inlier ratio, reprojection error on the sphere) plus optional robust refinement. - Compute scale ratio from matched structure (where applicable) or from triangulation/relative baseline cues derived from pose estimation; output NaN when scale is not identifiable. - Produce a reliability/confidence score combining: match quality, inlier statistics, rotation stability, and sensitivity tests across exposure-normalized variants. Outputs: - CLI that accepts two selected image paths from your collection. - JSON results plus a concise, parseable plain-text report (e.g., one line per metric: connected=..., scale_ratio=..., yaw_deg=..., pitch_deg=..., confidence=..., notes=...). Libraries: OpenCV, NumPy, scikit-image; install via pip/conda. Timeline is practical once sample folder contents are confirmed and expected image resolutions

@TeraByte26

Hi Tom, I will deliver a Python CLI that loads your equirectangular set, compares any two images and outputs a JSON Waiting for your response in chat! Best Regards.

@Aaleen110

The core of this is detecting if two equirectangular photos are the same shot, which means aligning features and checking their spatial relationship. I'll use Python with OpenCV for image processing, specifically for feature detection and matching, then NumPy for calculations. For feature detection, I'll use SIFT or ORB descriptors, whichever proves more robust on your dataset for identifying consistent points across images, as the equirectangular projection can distort features significantly. Then, I'll use these matches to estimate a fundamental matrix to check for epipolar geometry, which will confirm if they are connected and also give us the yaw and pitch differences relative to each other. The scale ratio will be derived from the distances between matched features. The reliability score will be a composite based on the number of good feature matches, the reprojection error from the fundamental matrix estimation, and the consistency of the scale ratio across multiple feature sets. The brief doesn't specify how the "connected" status should be interpreted beyond the angle check, so I'll assume "connected" means they share enough consistent features to establish a meaningful geometric relationship, and if not, they are not connected. I will need to understand the typical resolution and file formats of your equirectangular photos to optimize the processing pipeline. Preferred Freelancer here, 5.0 over 10 reviews, no missed deadline and nothing over an agreed price yet. I propose a short call on Freelancer to confirm the exact image format you are working with and to discuss the desired structure for the concise text report.

@vishal1145

Your equirectangular matcher will fail if you rely on standard feature detection - spherical distortion at the poles breaks SIFT/ORB keypoint descriptors. You need projection-aware feature extraction that samples uniformly across latitude bands. Quick questions - are these images from a multi-camera rig where overlap zones are predictable, or handheld shots where connection geometry varies wildly? And what's your tolerance threshold for "connected" - 30% overlap minimum or tighter? Here is the architectural approach: - PYTHON + OPENCV: Project equirectangular to cubemap faces, run ORB feature matching per face to avoid polar singularities, then back-project matches to spherical coordinates for yaw/pitch calculation. - IMAGE PROCESSING: Normalize exposure using histogram equalization before matching to handle lighting variance, filter matches using RANSAC homography with reprojection error under 3 pixels for confidence scoring. - COMPUTER VISION: Calculate scale ratio from median keypoint distance changes, output JSON with connection boolean, yaw/pitch angles in degrees, overlap percentage, and confidence score 0-1 based on inlier count. I've built similar spherical image alignment pipelines for 360° camera calibration systems that handled 2000+ image pairs with 94% match accuracy. Let's schedule a 20-minute call to review your sample dataset and confirm the geometric constraints before I architect the full pipeline.

@sf264

Hello, I can build the Python/OpenCV workflow to compare two equirectangular images and determine their connectivity, yaw/pitch relationship, scale ratio where identifiable, and confidence score. For the panorama distortion, I’ll use spherical/cubemap-aware feature matching with geometric verification rather than relying on basic 2D matching alone. I’ll also test against exposure changes and stitching artefacts and return clean JSON plus a concise CLI-friendly report. I can validate the thresholds against the provided sample dataset so the confidence score is based on measurable matching accuracy rather than arbitrary values. I’m ready to start with the sample images and build the first working comparison pipeline. Best regards, Fahad.

@shayankhan333

Same-angle detection on equirectangulars is really a spherical feature-matching problem, not a flat one. Projecting each pair to cubemap faces before running SIFT or SuperPoint avoids the pole distortion that wrecks matches near the top and bottom of the sphere. I'll build a CLI that loads any two images, matches features across cube faces, solves for yaw/pitch and scale from inlier geometry, and writes a JSON report with a confidence score tied to inlier ratio and reprojection error. I can jump in right away. 1) Should the confidence score be calibrated against a labelled ground-truth subset you provide? 2) Any preference between SIFT, AKAZE or a learned matcher like LightGlue? Cheers Shayan

@albertc1996

I'll build a Python CLI that, for any pair of your equirectangular images, decides whether they show the same viewpoint (and whether they are connected), then computes the scale ratio, connected yaw/pitch, and a 0-100 reliability score. Output goes both to JSON and to a concise, parseable KEY: VALUE text report. Approach: - Preprocess for robustness: normalize exposure/lighting and mask stitching artefacts so they don't create false matches. - Match features (SIFT/AKAZE generated from spherical unwrapped neighborhoods) with RANSAC geometric verification — low inlier or ambiguous pairs are rejected, not reported as connected. - Estimate yaw/pitch from the rotation between frames, scale ratio from median keypoint disparity. - A reliability score combining inlier ratio, geometric consistency, and overlap coverage, flagged clearly when the pair is ambiguous. The differentiator: I will benchmark on your sample dataset and give you a repeatable accuracy metric — a small table with precision, recall/false-positive rate, and yaw/pitch error against your labels. None of the usual offers provide that verification, and I think it matters for trusting the output (especially given the lighting and stitching errors present). Plan: two milestones — verify the matching approach on your sample dataset (day 1-3), then the full CLI + text report (day 7-8). Questions: should 'connected' rely only on visual overlap, or may I use filename/grouping as a tie-break?

@vladang

Your 12 sample panoramas are mostly bare white walls, which is exactly where feature matching gives false positives. The window frames and floor planks carry the real signal, so the script has to reward matches spread across the room, not one cluster on the window. I'd reproject each panorama into cube faces before running SIFT, since the raw equirectangular image is stretched near the top and bottom and cut at the left edge. Matched points become bearings on a unit sphere, a RANSAC rotation fit gives the yaw and pitch, and the scale ratio comes from the matched keypoint sizes. Confidence is built from the inlier count and how many faces they span, with the threshold set on your own labeled pairs so the same accuracy metric can be rerun whenever you add images. Output is one JSON object per pair (connected, same_angle, yaw, pitch, scale_ratio, confidence, inliers) that you can pipe or forward as-is. I haven't shipped a panorama-matching tool before, so that repeatable metric on your data is how I'd prove the approach rather than a portfolio link. First working CLI run on your 12 images in 3 days, and we can set that as the first milestone, released only when the numbers hold up. Which of the sample pairs do you already know are connected? Five or six labeled pairs are enough to start the accuracy check.

@jonasdedzo

Hi there, I can build a Python/OpenCV workflow that compares two equirectangular panoramas and determines whether their viewpoints are connected, while also estimating the scale ratio, yaw, pitch, and confidence score. I’ll use panorama-aware feature matching with geometric verification such as RANSAC to reduce false positives from lighting changes, exposure differences, and stitching artefacts. The workflow will run from the CLI and return clean JSON containing the connection result, estimated transformation, confidence, and useful matching statistics. I’ll also test the approach against your sample dataset and provide a repeatable accuracy metric with clear thresholds. The project will be delivered in 3 milestones: 1) matching and viewpoint estimation — HKD 800 / 3 days; 2) robustness, confidence scoring and accuracy testing — HKD 900 / 4 days; 3) CLI, JSON output, documentation and final testing — HKD 700 / 3 days. Total: HKD 2,400 / 10 days. Looking forward to work with you. Thanks

@emilesd617

Hi, I am a python developer with 8 years of rich experience in software development, with a background in computer vision, image processing, image analysis, and OpenCV based solutions. I am familiar with Python, OpenCV, NumPy, scikit-image, feature matching, geometric analysis, image registration, and computer vision workflows. For your equirectangular images, I can build a CLI workflow that compares any selected pair and determines whether their viewpoints are connected, while estimating the scale ratio, yaw, pitch, and a confidence score. I can use panorama-aware feature matching and geometric verification rather than relying on simple pixel similarity, with preprocessing to handle exposure changes and minor stitching artefacts. The output can be a concise JSON or text report containing the connection decision, estimated parameters, confidence, and matching metrics, with a repeatable evaluation process against your sample dataset. I'm an individual freelancer and can work on any time zone you want. Please contact me with the best time for you to have a quick chat. Looking forward to discussing more details. Thanks. Emile.

@sabaehsan

Greetings, I see you're looking for a Python script to analyze your equirectangular photo collection and determine if two images were taken from the same angle. My approach would involve using libraries like OpenCV and NumPy to develop a robust workflow that accurately checks for connections, calculates scale ratios, and assesses yaw and pitch angles. I would incorporate techniques to handle variations in lighting and minor stitching artifacts to ensure reliable results. The output will be structured in a user-friendly text report, allowing you to easily parse or share the findings. I have experience working with image processing and viewpoint matching, which will help achieve the accuracy you need. I’m excited to discuss how we can tackle this project together. Best regards, Saba Ehsan

@invoketech

Hello, we have experience with COMPUTER VISION, OPENCV, PYTHON & IMAGE MATCHING and have carefully reviewed your requirements. We can build a robust CLI-based solution to determine whether two equirectangular images are connected/same viewpoint and calculate scale ratio, yaw, pitch, and confidence score while handling lighting changes and stitching artifacts. WORKING FLOW: Image Processing → Normalize and preprocess panorama images. Feature Matching → Detect robust features and establish reliable correspondences. Geometric Analysis → Calculate connectivity, scale, yaw, and pitch between viewpoints. Validation → Apply outlier rejection and geometric checks to reduce false positives. Output → Generate concise, machine-readable JSON/text reports with confidence metrics. We can use Python, OpenCV, NumPy and scikit-image, with a straightforward pip/conda setup and CLI execution. We can also validate the approach against your sample dataset and provide repeatable accuracy metrics. I will deliver FULL SOURCE CODE, CLI TOOL, DOCUMENTATION, TESTING RESULTS, AND 3 YEARS OF POST-LAUNCH SUPPORT on time. I eagerly await your positive response. Thanks Invoke Tech

@JunaidBadroodien

Your project to develop a Python-based workflow for analyzing equirectangular images presents an exciting opportunity to enhance image analysis accuracy. The need to determine if two images were shot from the same angle, while also assessing their connectivity and scale, is crucial for many applications. I can create a robust solution leveraging OpenCV and NumPy, focusing on the reliability of results despite common challenges like lighting changes and stitching artifacts. The implementation will include functionalities to calculate the scale ratio, yaw, and pitch angles, as well as generate a confidence score, ensuring you receive comprehensive insights. The JSON output will be structured for easy parsing, and I will suggest a clear text report format for effortless forwarding. Having worked on similar projects involving viewpoint matching in VR imagery, I understand the nuances involved in achieving high accuracy. I will provide a detailed breakdown of the methodology to ensure transparency and repeatability in results, aligning closely with your expectations for robustness. Let's create something that not only meets your expectations but sets a new standard for quality. Regards Junaid