Image Segmentation
PyTorch
English
painting-vision-robotics-kit
semantic-segmentation
robotics
edge-ai
construction-ai
autonomous-painting
wall-painting-robot
paint-coverage-estimation
building-facade
drywall
skirting-detection
window-detection
lidar
depth-validation
segformer
deeplabv3
Eval Results (legacy)
Update code: real-machine G-code adapter, commissioning gate, machine_job runner, pump watchdog firmware, twin completion gate, realism and masking modules (card and weights unchanged)
4eecd03 verified Download application.py from constructelligence/painting-vision-robotics-kit: direct link, hf CLI and curl.
- Browser
- Download file 10.2 kB
-
https://huggingface.co/constructelligence/painting-vision-robotics-kit/resolve/main/application.py
- Command line
-
hf download hf://constructelligence/painting-vision-robotics-kit/application.py
-
curl -L -o application.py https://huggingface.co/constructelligence/painting-vision-robotics-kit/resolve/main/application.py
10.2 kB
| #!/usr/bin/env python3 | |
| """Application physics: how fast to move, how far apart to pass, and how much paint, for a film-thickness target. | |
| The planner says *where* the tool goes; a coating spec says *how thick* the film must be. This module joins them. | |
| Every relation is the standard one painters and coating inspectors use, with the assumptions written down: | |
| * **Airless spray fan width** at the wall = 2 × standoff × tan(fan angle / 2). Tip codes follow the common | |
| three-digit convention: first digit × 2 = fan width in inches at a 12 in standoff, last two digits = orifice in | |
| thousandths of an inch (e.g. ``517`` = 10 in fan, 0.017 in orifice). | |
| * **Tip flow** scales with the square root of pressure: Q = Q_rated × √(P / P_rated). ``TIP_FLOW_GPM`` holds | |
| typical water-rated flows at 2000 psi; a manufacturer's chart for the actual tip and coating always wins. | |
| * **Deposition.** With pass spacing ``s`` (fan width × (1 − overlap)) and traverse speed ``v``, the average wet film | |
| is WFT = Q × TE / (v × s), where TE is transfer efficiency (paint that reaches the wall, not the air). | |
| Dry film = WFT × volume solids. Solving for ``v`` gives the speed that hits a dry-film target. | |
| * **Roller.** Rollers are specified by spread rate: area per volume at the target film; one load covers | |
| ``load_ml / (DFT / VS)`` of wall, which sets how often the robot must reload. | |
| Units: SI internally (m, s, L, µm); inches/mils/gallons in and out where the trade uses them. | |
| python3 application.py spray --tip 517 --pressure-psi 2000 --standoff-mm 300 --dft-um 40 --vs 0.38 --area-m2 42 | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import math | |
| from dataclasses import dataclass, asdict | |
| GPM_TO_LPS = 3.785411784 / 60.0 | |
| INCH_MM = 25.4 | |
| MIL_UM = 25.4 | |
| # Typical water flow (US gal/min) at 2000 psi by orifice (thousandths of an inch). Order-of-magnitude values from | |
| # common airless tip charts — use the manufacturer's chart for the tip actually fitted. | |
| TIP_FLOW_GPM = {11: 0.12, 13: 0.18, 15: 0.24, 17: 0.31, 19: 0.38, 21: 0.47, 23: 0.57, 25: 0.67, 27: 0.78, 31: 1.03} | |
| class SprayTip: | |
| code: str | |
| fan_in_at_12: float | |
| orifice_thou: int | |
| def parse(code: str) -> "SprayTip": | |
| code = str(code).strip() | |
| if len(code) != 3 or not code.isdigit(): | |
| raise ValueError(f"tip code {code!r}: expected three digits such as 517") | |
| orifice = int(code[1:]) | |
| if orifice not in TIP_FLOW_GPM: | |
| raise ValueError(f"tip {code}: no flow figure for a 0.0{orifice:02d} in orifice; pass --flow-lpm") | |
| return SprayTip(code, int(code[0]) * 2.0, orifice) | |
| def fan_angle_deg(self) -> float: | |
| return math.degrees(2 * math.atan((self.fan_in_at_12 / 2) / 12.0)) | |
| def flow_lps(self, pressure_psi: float, rated_psi: float = 2000.0) -> float: | |
| return TIP_FLOW_GPM[self.orifice_thou] * GPM_TO_LPS * math.sqrt(pressure_psi / rated_psi) | |
| def fan_width_mm(standoff_mm: float, fan_angle_deg: float) -> float: | |
| return 2 * standoff_mm * math.tan(math.radians(fan_angle_deg) / 2) | |
| def spray_settings(flow_lps, fan_angle_deg, standoff_mm, dft_um, volume_solids, overlap=0.5, transfer_efficiency=0.65, | |
| coats=1, area_m2=None, max_speed_mm_s=1500.0, min_speed_mm_s=150.0, max_wet_um=200.0): | |
| """Pass spacing, traverse speed and paint for one coat (and the job, given an area). Raises on an impossible spec.""" | |
| if not 0 < volume_solids <= 1 or not 0 < transfer_efficiency <= 1 or not 0 <= overlap < 1: | |
| raise ValueError("volume_solids and transfer_efficiency must be in (0, 1], overlap in [0, 1)") | |
| width = fan_width_mm(standoff_mm, fan_angle_deg) | |
| spacing = width * (1 - overlap) | |
| wft_um = dft_um / volume_solids | |
| # WFT (m) = Q (m³/s) × TE / (v (m/s) × s (m)) -> v = Q × TE / (WFT × s) | |
| speed_m_s = flow_lps / 1000.0 * transfer_efficiency / (wft_um * 1e-6 * spacing / 1000.0) | |
| speed = speed_m_s * 1000.0 | |
| notes = [] | |
| if speed > max_speed_mm_s: | |
| notes.append(f"needs {speed:.0f} mm/s, above the {max_speed_mm_s:.0f} mm/s limit: use a smaller tip or lower pressure") | |
| if wft_um > max_wet_um: | |
| notes.append(f"{wft_um:.0f} µm wet in one coat is above ~{max_wet_um:.0f} µm, where wall paints sag: split into coats") | |
| if speed < min_speed_mm_s: | |
| notes.append(f"needs only {speed:.0f} mm/s: risk of runs; use a larger fan, a smaller orifice, or two thinner coats") | |
| out = {"fan_width_mm": round(width, 1), "pass_spacing_mm": round(spacing, 1), "wet_film_um": round(wft_um, 1), | |
| "wet_film_mils": round(wft_um / MIL_UM, 2), "dry_film_um": dft_um, "traverse_speed_mm_s": round(speed, 1), | |
| "flow_l_min": round(flow_lps * 60, 3), "transfer_efficiency": transfer_efficiency, | |
| "fan_angle_deg": round(fan_angle_deg, 2), "standoff_mm": standoff_mm, "notes": notes} | |
| if area_m2: | |
| paint_l = area_m2 * wft_um * 1e-6 * 1000.0 / transfer_efficiency * coats # litres pumped, incl. overspray | |
| spray_s = paint_l / flow_lps | |
| out.update({"area_m2": area_m2, "coats": coats, "paint_l": round(paint_l, 2), "paint_gal": round(paint_l / 3.785, 2), | |
| "trigger_on_time_min": round(spray_s / 60, 1), | |
| "pass_length_m": round(area_m2 * coats / (spacing / 1000.0), 1)}) | |
| return out | |
| def roller_settings(nap_load_ml, dft_um, volume_solids, roller_width_mm=230.0, overlap=0.2, area_m2=None, coats=1): | |
| """How much wall one roller load covers at the target film, and the reload count for an area.""" | |
| wft_um = dft_um / volume_solids | |
| per_load_m2 = nap_load_ml * 1e-6 / (wft_um * 1e-6) | |
| out = {"wet_film_um": round(wft_um, 1), "area_per_load_m2": round(per_load_m2, 3), | |
| "pass_spacing_mm": round(roller_width_mm * (1 - overlap), 1), | |
| "stroke_length_per_load_m": round(per_load_m2 / (roller_width_mm * (1 - overlap) / 1000.0), 2)} | |
| if area_m2: | |
| out.update({"loads": math.ceil(area_m2 * coats / per_load_m2), "paint_l": round(area_m2 * coats * wft_um * 1e-3, 2)}) | |
| return out | |
| def trigger_offsets(speed_mm_s, open_latency_s=0.05, close_latency_s=0.03): | |
| """How far before a stroke's start the gun must be told to open (and before its end to close) at this speed.""" | |
| return {"open_lead_mm": round(speed_mm_s * open_latency_s, 1), "close_lead_mm": round(speed_mm_s * close_latency_s, 1)} | |
| def spray_reaction(flow_lps, pressure_psi, density_kg_m3=1100.0): | |
| """The push the jet puts back on the gun, and so on whatever is holding it. | |
| Reaction is mass flow times exit speed: F = (Q rho) * sqrt(2 P / rho) = Q * sqrt(2 P rho). An airless tip at | |
| 2000 psi moving 1.17 L/min therefore pushes back with about 3.4 N (0.35 kgf). That is small next to a drone's | |
| thrust, and it is not small next to the *quality* budget: it acts for a whole pass, on a long boom, and it moves the | |
| nozzle off its standoff, which changes the fan width and so the film. | |
| ``density`` is the coating's (~1100 kg/m3 for wall paint); the pressure is the one at the tip, and a measured flow | |
| always beats the tip table. The model ignores the fan's impingement on the wall (a wall jet pushes back a little | |
| more) and any swirl: it is a lower bound, and it is stated as one. | |
| """ | |
| flow_lps, pressure_psi, density = float(flow_lps), float(pressure_psi), float(density_kg_m3) | |
| if flow_lps < 0 or pressure_psi < 0 or density <= 0: | |
| raise ValueError("flow, pressure and density must be non-negative (density positive)") | |
| pressure_pa = pressure_psi * 6894.757 | |
| exit_ms = math.sqrt(2.0 * pressure_pa / density) | |
| mass_flow = flow_lps / 1000.0 * density # L/s -> m3/s -> kg/s | |
| force = mass_flow * exit_ms | |
| return {"exit_ms": round(exit_ms, 1), "mass_flow_kg_s": round(mass_flow, 5), | |
| "reaction_n": round(force, 2), "reaction_kg": round(force / 9.80665, 3), | |
| "density_kg_m3": density, "pressure_psi": pressure_psi} | |
| def main(): | |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) | |
| sub = ap.add_subparsers(dest="mode", required=True) | |
| s = sub.add_parser("spray") | |
| s.add_argument("--tip", help="three-digit tip code, e.g. 517") | |
| s.add_argument("--flow-lpm", type=float, help="measured flow instead of the tip table") | |
| s.add_argument("--fan-deg", type=float, help="fan angle, with --flow-lpm") | |
| s.add_argument("--pressure-psi", type=float, default=2000) | |
| s.add_argument("--standoff-mm", type=float, default=300) | |
| s.add_argument("--dft-um", type=float, required=True, help="dry film per coat from the product data sheet") | |
| s.add_argument("--vs", type=float, required=True, help="volume solids, 0-1, from the product data sheet") | |
| s.add_argument("--overlap", type=float, default=0.5) | |
| s.add_argument("--te", type=float, default=0.65, help="transfer efficiency") | |
| s.add_argument("--area-m2", type=float) | |
| s.add_argument("--coats", type=int, default=1) | |
| r = sub.add_parser("roller") | |
| r.add_argument("--load-ml", type=float, default=60) | |
| r.add_argument("--dft-um", type=float, required=True) | |
| r.add_argument("--vs", type=float, required=True) | |
| r.add_argument("--width-mm", type=float, default=230) | |
| r.add_argument("--area-m2", type=float) | |
| r.add_argument("--coats", type=int, default=1) | |
| a = ap.parse_args() | |
| if a.mode == "spray": | |
| if a.tip: | |
| tip = SprayTip.parse(a.tip) | |
| flow, angle = tip.flow_lps(a.pressure_psi), tip.fan_angle_deg | |
| elif a.flow_lpm and a.fan_deg: | |
| flow, angle = a.flow_lpm / 60.0, a.fan_deg | |
| else: | |
| ap.error("give --tip, or --flow-lpm with --fan-deg") | |
| out = spray_settings(flow, angle, a.standoff_mm, a.dft_um, a.vs, a.overlap, a.te, a.coats, a.area_m2) | |
| out["trigger"] = trigger_offsets(out["traverse_speed_mm_s"]) | |
| out["reaction"] = spray_reaction(flow, a.pressure_psi) | |
| else: | |
| out = roller_settings(a.load_ml, a.dft_um, a.vs, a.width_mm, area_m2=a.area_m2, coats=a.coats) | |
| print(json.dumps(out, indent=2)) | |
| if __name__ == "__main__": | |
| main() | |