Energy savings estimator

2025-11-08 12:27 UTC gpt-5-thinking Open in ChatGPT ↗

You

I need a small python program that receives a simple line drawing of my house and calculates how much energy I would save if I insulated my 100% uninsulatd house. The height is uniform. The ceiling is in uninsulated. If there is a gap in my line , it indicates a window.

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Got it! Below is a compact, self-contained Python script that:

• reads a simple black-on-white line drawing (PNG/JPG) of your house’s outer outline,
• treats gaps in the outer line as windows,
• assumes uniform building height,
• estimates wall area (minus windows) and roof area from the image scale,
• compares heat loss before vs after insulation using Heating Degree Days, and
• prints annual energy savings (kWh) and cost savings.

It works best if the outline is an axis-aligned rectangle drawn with a solid line; any missing segments along the four edges are treated as windows. You can tweak all assumptions at the top (U-values, HDD, energy price, window height, what gets insulated, etc.).

How to use

1. Save this as insulation_savings.py.
2. Prepare a black line on white background image (e.g., house.png) where the rectangle’s edges follow the image axes; gaps = windows.
3. Measure (or decide) your scale in meters per pixel (e.g., if 100 px = 1 m, then m_per_px = 0.01).
4. Run:

python insulation_savings.py --image house.png --m-per-px 0.01 --height 2.7 --hdd 2200 --price 0.22

---

insulation_savings.py

#
# Minimal tool to estimate annual heating energy savings from insulating
# an uninsulated rectangular house outline drawn as a black line on a white image.
# Gaps in the outline are treated as windows.
#
# Formula: Annual kWh ≈ HDD(°C·day) * 24(h/day) * (UA_before - UA_after) / 1000
# where UA = Σ(U_i * A_i)
#
# Requirements: Pillow, numpy
#   pip install pillow numpy
#
# Example:
#   python insulation_savings.py --image house.png --m-per-px 0.01 --height 2.7 --hdd 2200 --price 0.22

import argparse
from PIL import Image
import numpy as np
from dataclasses import dataclass

@dataclass
class UValues:
    wall_unins: float = 1.7   # W/m²·K (typical uninsulated solid wall)
    wall_ins:   float = 0.30  # W/m²·K (insulated wall target)
    roof_unins: float = 2.0   # W/m²·K (uninsulated roof/ceiling)
    roof_ins:   float = 0.20  # W/m²·K (well-insulated roof)
    window:     float = 2.7   # W/m²·K (double-glazed baseline, unchanged unless you change it)

def detect_outline_bbox_and_window_gaps(img_gray: np.ndarray, band: int = 3, thresh: int = 200):
    """
    Assumes an axis-aligned outer rectangle drawn in dark pixels on white background.
    Returns:
        (minx, miny, maxx, maxy), total_window_gap_pixels_along_edges
    """
    # Binarize: True for "ink"/line pixels
    ink = img_gray < thresh
    if not np.any(ink):
        raise ValueError("No drawing detected (image appears blank).")

    ys, xs = np.where(ink)
    minx, maxx = xs.min(), xs.max()
    miny, maxy = ys.min(), ys.max()

    # Helper: check whether along a scan position we find any ink inside a band from the edge
    def has_ink_on_row(y, x_from, x_to):
        y0 = max(y - band, 0)
        y1 = min(y + band + 1, ink.shape[0])
        return np.any(ink[y0:y1, x_from:x_to])

    def has_ink_on_col(x, y_from, y_to):
        x0 = max(x - band, 0)
        x1 = min(x + band + 1, ink.shape[1])
        return np.any(ink[y_from:y_to, x0:x1])

    window_gap_px = 0

    # Top edge: scan x across [minx..maxx] at y=miny
    gap = 0
    for x in range(minx, maxx + 1):
        if has_ink_on_row(miny, x, x + 1):
            if gap > 0:
                window_gap_px += gap
                gap = 0
        else:
            gap += 1
    if gap > 0:
        window_gap_px += gap

    # Bottom edge: y=maxy
    gap = 0
    for x in range(minx, maxx + 1):
        if has_ink_on_row(maxy, x, x + 1):
            if gap > 0:
                window_gap_px += gap
                gap = 0
        else:
            gap += 1
    if gap > 0:
        window_gap_px += gap

    # Left edge: x=minx
    gap = 0
    for y in range(miny, maxy + 1):
        if has_ink_on_col(minx, y, y + 1):
            if gap > 0:
                window_gap_px += gap
                gap = 0
        else:
            gap += 1
    if gap > 0:
        window_gap_px += gap

    # Right edge: x=maxx
    gap = 0
    for y in range(miny, maxy + 1):
        if has_ink_on_col(maxx, y, y + 1):
            if gap > 0:
                window_gap_px += gap
                gap = 0
        else:
            gap += 1
    if gap > 0:
        window_gap_px += gap

    return (minx, miny, maxx, maxy), window_gap_px

def main():
    parser = argparse.ArgumentParser(description="Estimate annual heating energy savings from insulation using a simple line drawing.")
    parser.add_argument("--image", required=True, help="Path to black-on-white house outline image (PNG/JPG). Rectangle outline with gaps as windows.")
    parser.add_argument("--m-per-px", type=float, required=True, help="Scale: meters per pixel (e.g., if 100 px = 1 m, use 0.01).")
    parser.add_argument("--height", type=float, default=2.5, help="Uniform wall height in meters. Default 2.5 m.")
    parser.add_argument("--window-height", type=float, default=1.2, help="Assumed window height (m). Default 1.2 m.")
    parser.add_argument("--hdd", type=float, default=2000, help="Annual heating degree days (°C·day). Default 2000.")
    parser.add_argument("--price", type=float, default=0.20, help="Energy price (currency per kWh). Default 0.20.")
    parser.add_argument("--insulate-walls", action="store_true", help="If set, walls get insulated.")
    parser.add_argument("--insulate-roof", action="store_true", help="If set, roof gets insulated.")
    parser.add_argument("--u-wall-unins", type=float, default=UValues.wall_unins, help="U-value uninsulated wall (W/m²K).")
    parser.add_argument("--u-wall-ins",   type=float, default=UValues.wall_ins,   help="U-value insulated wall (W/m²K).")
    parser.add_argument("--u-roof-unins", type=float, default=UValues.roof_unins, help="U-value uninsulated roof (W/m²K).")
    parser.add_argument("--u-roof-ins",   type=float, default=UValues.roof_ins,   help="U-value insulated roof (W/m²K).")
    parser.add_argument("--u-window",     type=float, default=UValues.window,     help="U-value of windows (W/m²K).")
    parser.add_argument("--band", type=int, default=3, help="Detection band (pixels) near the edges to find the line. Default 3.")
    parser.add_argument("--thresh", type=int, default=200, help="Grayscale threshold for ink detection (0-255). Default 200.")
    args = parser.parse_args()

    # Load and grayscale
    img = Image.open(args.image).convert("L")
    gray = np.array(img)

    # Detect rectangle bbox and window gaps along edges
    (minx, miny, maxx, maxy), window_gap_px = detect_outline_bbox_and_window_gaps(gray, band=args.band, thresh=args.thresh)

    # Dimensions in pixels
    width_px  = maxx - minx
    height_px = maxy - miny

    # Convert to meters
    m_per_px = args.m_per_px
    width_m  = width_px  * m_per_px
    depth_m  = height_px * m_per_px

    # Perimeter and areas
    perimeter_m = 2.0 * (width_m + depth_m)
    floor_area_m2 = width_m * depth_m
    roof_area_m2 = floor_area_m2  # flat assumption
    window_length_m = window_gap_px * m_per_px
    window_area_m2 = window_length_m * args.window_height  # simplistic: windows run full gap length with fixed height
    wall_area_m2 = max(perimeter_m * args.height - window_area_m2, 0.0)

    # U-values
    u = UValues(
        wall_unins=args.u_wall_unins,
        wall_ins=args.u_wall_ins,
        roof_unins=args.u_roof_unins,
        roof_ins=args.u_roof_ins,
        window=args.u_window
    )

    # UA before & after
    UA_before = u.wall_unins * wall_area_m2 + u.roof_unins * roof_area_m2 + u.window * window_area_m2
    UA_after  = (u.wall_ins if args.insulate_walls else u.wall_unins) * wall_area_m2 \
                + (u.roof_ins if args.insulate_roof else u.roof_unins) * roof_area_m2 \
                + u.window * window_area_m2  # windows unchanged here

    # Annual energy (kWh)
    annual_kWh_before = args.hdd * 24.0 * UA_before / 1000.0
    annual_kWh_after  = args.hdd * 24.0 * UA_after  / 1000.0
    savings_kWh = max(annual_kWh_before - annual_kWh_after, 0.0)
    savings_cost = savings_kWh * args.price

    # Report
    print("=== Geometric interpretation from image ===")
    print(f"Outline bbox (px): minx={minx}, miny={miny}, maxx={maxx}, maxy={maxy}")
    print(f"Width x Depth (m): {width_m:.2f} m x {depth_m:.2f} m")
    print(f"Perimeter (m):     {perimeter_m:.2f}")
    print(f"Detected window gap length (m): {window_length_m:.2f}")
    print(f"Assumed window height (m):      {args.window_height:.2f}")
    print(f"Window area (m²):               {window_area_m2:.2f}")
    print(f"Wall height (m):                {args.height:.2f}")
    print(f"Wall area minus windows (m²):   {wall_area_m2:.2f}")
    print(f"Roof area (m²):                 {roof_area_m2:.2f}")
    print()
    print("=== Thermal model ===")
    print(f"HDD (°C·day): {args.hdd:.0f}")
    print(f"U-values (W/m²K): wall unins={u.wall_unins}, wall ins={u.wall_ins}, roof unins={u.roof_unins}, roof ins={u.roof_ins}, window={u.window}")
    print(f"UA before (W/K): {UA_before:.1f}")
    print(f"UA after  (W/K): {UA_after:.1f}")
    print()
    print("=== Results ===")
    print(f"Annual energy BEFORE: {annual_kWh_before:,.0f} kWh")
    print(f"Annual energy AFTER:  {annual_kWh_after:,.0f} kWh")
    print(f"Annual SAVINGS:       {savings_kWh:,.0f} kWh")
    print(f"At {args.price:.2f} per kWh → SAVINGS ≈ {savings_cost:,.0f}")
    print()
    print("Notes:")
    print("- This simple method assumes an axis-aligned rectangular outline and treats any missing line segments on the edges as windows.")
    print("- Windows are modeled as fixed height; adjust --window-height if yours differ.")
    print("- Set --insulate-walls / --insulate-roof to choose what you plan to insulate.")
    print("- If your outline isn’t a rectangle, or you want better window detection, you’ll need a more advanced contour-based approach.")

if __name__ == "__main__":
    main()

Assumptions (quick tweaks)

• Outline is a rectangle aligned to the image axes.
• Wall height default 2.5 m (--height).
• Window height default 1.2 m (--window-height).
• U-values are typical placeholders; adjust to your local codes/materials.
• HDD (--hdd) depends on climate; use your local annual HDD.
• Insulation scope: use --insulate-walls and/or --insulate-roof.
• Energy price (--price) is in your currency per kWh.

If you want, I can adapt this to handle non-rectangular shapes (outer contour detection) or to infer window height from a second reference line you draw—just say the word and I’ll fold it in.

You

Don’t use images. I will provide a dxf drawing so that the scale is correct

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Perfect—DXF is even better. Here’s a compact Python script that:

• reads your DXF,
• assumes the house outline is an axis-aligned rectangle drawn with LINE or LWPOLYLINE segments,
• treats gaps along the four outer edges as windows,
• uses your true DXF scale (with an optional units scale factor),
• and computes annual energy savings from insulating walls and/or the (uninsulated) ceiling.

Save as insulation_savings_dxf.py, then run e.g.:

pip install ezdxf numpy
python insulation_savings_dxf.py --dxf house.dxf --height 2.7 --hdd 2200 --price 0.22 --insulate-walls --insulate-roof

If your DXF is in millimetres, use --units-scale 0.001 to convert to meters.

---

insulation_savings_dxf.py

#
# Estimate annual heating energy savings from insulating a 100% uninsulated,
# axis-aligned rectangular house footprint drawn in a DXF.
# Gaps along the outer rectangle edges are treated as windows.
#
# Geometry:
# - Detect the bounding rectangle from all LINE / LWPOLYLINE segments.
# - For each of the 4 sides (x=min, x=max, y=min, y=max), build 1D coverage
#   intervals from segments that lie on that side (within tolerance).
# - Uncovered length on that side = window length on that side.
#
# Thermals:
# Annual kWh ≈ HDD(°C·day) * 24(h/day) * (UA_before - UA_after) / 1000
# with UA = Σ(U_i * A_i).
#
# Example:
#   python insulation_savings_dxf.py --dxf house.dxf --height 2.7 --hdd 2200 --price 0.22 \
#     --window-height 1.2 --insulate-walls --insulate-roof --units-scale 1.0
#
# Requirements: pip install ezdxf numpy

import argparse
from dataclasses import dataclass
import ezdxf
import numpy as np
from typing import List, Tuple

@dataclass
class UValues:
    wall_unins: float = 1.7   # W/m²·K
    wall_ins:   float = 0.30  # W/m²·K
    roof_unins: float = 2.0   # W/m²·K (ceiling uninsulated baseline)
    roof_ins:   float = 0.20  # W/m²·K
    window:     float = 2.7   # W/m²·K (kept constant unless changed)

def merge_intervals(intervals: List[Tuple[float, float]], tol: float = 0.0) -> List[Tuple[float,float]]:
    """Merge [a,b] intervals on a line."""
    if not intervals:
        return []
    ints = sorted([(min(a,b), max(a,b)) for a,b in intervals])
    merged = [ints[0]]
    for a,b in ints[1:]:
        la, lb = merged[-1]
        if a <= lb + tol:
            merged[-1] = (la, max(lb, b))
        else:
            merged.append((a,b))
    return merged

def total_gap_length(side_min: float, side_max: float, covered: List[Tuple[float,float]]) -> float:
    """Length on [side_min, side_max] not covered by intervals."""
    if side_max < side_min:
        side_min, side_max = side_max, side_min
    merged = merge_intervals(covered, tol=0.0)
    covered_len = sum(max(0.0, min(b, side_max) - max(a, side_min)) for a,b in merged)
    total_len = side_max - side_min
    return max(0.0, total_len - covered_len)

def extract_segments(doc, units_scale=1.0, layer_filter=None):
    """
    Return list of segments [(x1,y1,x2,y2)] from LINE and LWPOLYLINE.
    units_scale converts DXF units to meters (e.g., mm -> m = 0.001).
    Optional layer_filter: set of allowed layer names.
    """
    msp = doc.modelspace()
    segs = []

    def on_layer(entity):
        return (layer_filter is None) or (entity.dxf.layer in layer_filter)

    # LINE entities
    for e in msp.query("LINE"):
        if not on_layer(e): continue
        x1,y1 = e.dxf.start.x * units_scale, e.dxf.start.y * units_scale
        x2,y2 = e.dxf.end.x   * units_scale, e.dxf.end.y   * units_scale
        segs.append((x1,y1,x2,y2))

    # LWPOLYLINE entities
    for e in msp.query("LWPOLYLINE"):
        if not on_layer(e): continue
        pts = [(p[0]*units_scale, p[1]*units_scale) for p in e.get_points("xy")]
        if e.closed and len(pts) >= 2:
            pts = pts + [pts[0]]
        for (x1,y1),(x2,y2) in zip(pts[:-1], pts[1:]):
            segs.append((x1,y1,x2,y2))

    return segs

def project_to_side_intervals(segs, side, coord, span_min, span_max, tol):
    """
    Build coverage intervals along a side.
    side: 'left','right' -> vertical line x=coord, span is y; 'bottom','top' -> horizontal line y=coord, span is x.
    For each segment nearly coincident with the side (distance < tol), add its projected [t0,t1] on the span axis.
    """
    intervals = []
    if side in ("left","right"):
        # vertical side x = coord; span along y
        for x1,y1,x2,y2 in segs:
            # if nearly vertical AND within tol of side line
            if abs(x1 - x2) < tol and abs((x1 + x2)/2 - coord) < tol:
                a, b = sorted([y1, y2])
                # clamp to span
                a = max(a, span_min); b = min(b, span_max)
                if b > a:
                    intervals.append((a,b))
            # if segment crosses the side line and is nearly on it (rare for crooked lines) -> ignore to keep simple
    else:
        # horizontal side y = coord; span along x
        for x1,y1,x2,y2 in segs:
            if abs(y1 - y2) < tol and abs((y1 + y2)/2 - coord) < tol:
                a, b = sorted([x1, x2])
                a = max(a, span_min); b = min(b, span_max)
                if b > a:
                    intervals.append((a,b))
    return intervals

def main():
    ap = argparse.ArgumentParser(description="Estimate annual heating energy savings from a DXF outline with window gaps.")
    ap.add_argument("--dxf", required=True, help="Path to the DXF file (axis-aligned rectangle outline; gaps = windows).")
    ap.add_argument("--units-scale", type=float, default=1.0, help="Scale factor to convert DXF units to meters (e.g., mm->m: 0.001).")
    ap.add_argument("--height", type=float, default=2.5, help="Uniform wall height (m).")
    ap.add_argument("--window-height", type=float, default=1.2, help="Assumed window height (m).")
    ap.add_argument("--hdd", type=float, default=2000, help="Annual heating degree days (°C·day).")
    ap.add_argument("--price", type=float, default=0.20, help="Energy price (currency/kWh).")
    ap.add_argument("--insulate-walls", action="store_true", help="Insulate walls.")
    ap.add_argument("--insulate-roof", action="store_true", help="Insulate roof/ceiling.")
    ap.add_argument("--u-wall-unins", type=float, default=UValues.wall_unins, help="U-value uninsulated wall (W/m²K).")
    ap.add_argument("--u-wall-ins",   type=float, default=UValues.wall_ins,   help="U-value insulated wall (W/m²K).")
    ap.add_argument("--u-roof-unins", type=float, default=UValues.roof_unins, help="U-value uninsulated roof/ceiling (W/m²K).")
    ap.add_argument("--u-roof-ins",   type=float, default=UValues.roof_ins,   help="U-value insulated roof/ceiling (W/m²K).")
    ap.add_argument("--u-window",     type=float, default=UValues.window,     help="U-value windows (W/m²K).")
    ap.add_argument("--tol", type=float, default=0.005, help="Geometric tolerance (m) to detect lines on each side (default 5 mm).")
    ap.add_argument("--layer", action="append", help="Optional: restrict to these layer names (can repeat).")
    args = ap.parse_args()

    # Load DXF
    doc = ezdxf.readfile(args.dxf)

    # Segments in meters
    layer_filter = set(args.layer) if args.layer else None
    segs = extract_segments(doc, units_scale=args.units_scale, layer_filter=layer_filter)
    if not segs:
        raise SystemExit("No LINE/LWPOLYLINE geometry found (check layer filter or file).")

    # Bounding rectangle from all endpoints
    pts = np.array([(x1,y1) for x1,y1,_,_ in segs] + [(x2,y2) for _,_,x2,y2 in segs], dtype=float)
    minx, miny = pts.min(axis=0)
    maxx, maxy = pts.max(axis=0)

    # Basic dimensions
    width  = maxx - minx
    depth  = maxy - miny
    if width <= 0 or depth <= 0:
        raise SystemExit("Degenerate bounding box—are all points collinear?")

    # Build coverage on each side
    left_intervals   = project_to_side_intervals(segs, "left",   minx, miny, maxy, args.tol)
    right_intervals  = project_to_side_intervals(segs, "right",  maxx, miny, maxy, args.tol)
    bottom_intervals = project_to_side_intervals(segs, "bottom", miny, minx, maxx, args.tol)
    top_intervals    = project_to_side_intervals(segs, "top",    maxy, minx, maxx, args.tol)

    gap_left   = total_gap_length(miny, maxy, left_intervals)
    gap_right  = total_gap_length(miny, maxy, right_intervals)
    gap_bottom = total_gap_length(minx, maxx, bottom_intervals)
    gap_top    = total_gap_length(minx, maxx, top_intervals)
    window_gap_total = gap_left + gap_right + gap_bottom + gap_top  # meters of opening along edges

    # Areas
    perimeter = 2.0 * (width + depth)
    floor_area = width * depth
    roof_area = floor_area  # flat roof assumption
    window_area = window_gap_total * args.window_height
    wall_area = max(perimeter * args.height - window_area, 0.0)

    # U-values
    u = UValues(
        wall_unins=args.u_wall_unins,
        wall_ins=args.u_wall_ins,
        roof_unins=args.u_roof_unins,
        roof_ins=args.u_roof_ins,
        window=args.u_window
    )

    # UA (W/K)
    UA_before = u.wall_unins * wall_area + u.roof_unins * roof_area + u.window * window_area
    UA_after  = (u.wall_ins if args.insulate_walls else u.wall_unins) * wall_area \
              + (u.roof_ins if args.insulate_roof else u.roof_unins) * roof_area \
              + u.window * window_area

    # Energy (kWh/year)
    annual_kWh_before = args.hdd * 24.0 * UA_before / 1000.0
    annual_kWh_after  = args.hdd * 24.0 * UA_after  / 1000.0
    savings_kWh = max(annual_kWh_before - annual_kWh_after, 0.0)
    savings_cost = savings_kWh * args.price

    # Report
    print("=== Geometry from DXF ===")
    print(f"DXF units scale to meters: {args.units_scale}")
    print(f"Bounding rectangle (m): width={width:.3f} depth={depth:.3f}")
    print(f"Perimeter (m): {perimeter:.3f}")
    print(f"Gaps (m): left={gap_left:.3f}, right={gap_right:.3f}, bottom={gap_bottom:.3f}, top={gap_top:.3f}")
    print(f"Total window gap length (m): {window_gap_total:.3f}")
    print(f"Assumed window height (m): {args.window_height:.2f}")
    print(f"Window area (m²): {window_area:.2f}")
    print(f"Wall height (m): {args.height:.2f}")
    print(f"Wall area minus windows (m²): {wall_area:.2f}")
    print(f"Roof area (m²): {roof_area:.2f}")

    print("\n=== Thermal model ===")
    print(f"HDD (°C·day): {args.hdd:.0f}")
    print(f"U-values (W/m²K): wall unins={u.wall_unins}, wall ins={u.wall_ins}, roof unins={u.roof_unins}, roof ins={u.roof_ins}, window={u.window}")
    print(f"UA BEFORE (W/K): {UA_before:.1f}")
    print(f"UA AFTER  (W/K): {UA_after:.1f}")

    print("\n=== Results ===")
    print(f"Annual energy BEFORE: {annual_kWh_before:,.0f} kWh")
    print(f"Annual energy AFTER:  {annual_kWh_after:,.0f} kWh")
    print(f"Annual SAVINGS:       {savings_kWh:,.0f} kWh")
    print(f"At {args.price:.2f} per kWh → SAVINGS ≈ {savings_cost:,.0f}")

    print("\nNotes:")
    print("- Outline must be an axis-aligned rectangle. Any missing segment along an edge is treated as a window opening.")
    print("- If your DXF uses mm, pass --units-scale 0.001. If cm, 0.01. If already meters, leave as 1.0.")
    print("- For messy drawings, use --layer to restrict which layer(s) contain the outline, e.g., --layer OUTLINE --layer EXTERIOR.")
    print("- Windows are modeled with a fixed height; change --window-height to your typical head/jamb dimensions.")
    print("- The ceiling/roof is assumed initially uninsulated; enable --insulate-roof to model adding insulation there.")
    print("- This is a steady-state HDD model (no thermal mass/infiltration). You can tune U-values to match local practice.")

if __name__ == "__main__":
    main()

Quick tips

• If your rectangle is slightly skewed, increase --tol (e.g., 0.02 for 2 cm).
• Have windows only on specific sides? That’s OK—only those edges with gaps will contribute.
• Want non-rectangular footprints or rotated buildings? I can extend this to detect the oriented minimum bounding box and build side intervals along that orientation.