img2img, Inpainting & Outpainting

Plain text-to-image starts from pure noise. img2img starts from your image instead: it adds some noise back onto an existing picture, then denoises toward your prompt. Because it began from your image rather than static, the output keeps that image's structure - and the single dial that governs how much survives is denoising strength, a value from 0 to 1.

At low strength (around 0.2 to 0.4) the model barely changes anything - perfect for a gentle restyle, a material swap, a lighting shift while the composition holds rock-steady. At mid strength (0.5 to 0.6) it reinterprets more freely but still respects the overall layout - the sweet spot for turning a rough conditioned pass into a polished render. Push it high (0.75 and up) and it keeps only a loose echo of the original before drifting toward an essentially new scene. Strength is your fidelity dial: turn it down to stay faithful, up to reinvent. A worked feel for the numbers: at 0.3 a grey concrete room becomes the same room warmed to travertine with the furniture untouched; at 0.55 the palette, textiles and light all reinterpret while the sofa stays where it sits; at 0.85 you have gambled the room away for a new one that merely rhymes with it. The reliable habit is to start low and creep up - it is far easier to add change than to recover a composition you have already dissolved. Master this one dial and you can specify, in advance, exactly how much of the original you are willing to spend.

Often you love the render except for one thing - a garbled window, an awkward tree, a material you want changed on a single wall. Inpainting is the surgical fix: you paint a mask over just that region, and the model regenerates only inside the mask while leaving every pixel outside it untouched. Prompt what the region should become, and the model fills it to blend seamlessly with its surroundings, reading the light and style at the mask's edge so the patch belongs.

This is the control that makes AI renders usable in practice. Instead of re-rolling a whole image and losing everything good about it to fix one flaw, you edit locally - exactly like retouching, but generative. Inpainting is how you correct hallucinations (a stair that leads nowhere, a mullion that can't exist), swap elements (this sofa for that one, this door for a jaali screen), or refine a detail without disturbing the rest. A few settings decide whether the patch reads or betrays itself. Mask feathering softens the mask edge so new pixels graduate into the old instead of showing a seam. Masked denoising strength works just like img2img: keep it low (about 0.4) for a subtle change, higher for a full replacement. And 'inpaint only masked' (at full resolution) tells the tool to work at high detail inside the mask rather than smearing a whole-image pass across it. Combine inpainting with ControlNet and you can even hold the geometry inside the masked region - restyle a window's glazing while a Canny or MLSD map keeps its exact frame.

The mirror image of inpainting extends outward. Outpainting masks new, empty canvas around your existing image and asks the model to invent what continues past the original edge - more of the street, more sky above the parapet, the room the doorway leads into. The original stays as an anchor; the model reads its style, light and perspective and grows a plausible extension that lines up with what is already there.

For designers this solves two everyday problems. First, reframing: a render cropped too tight becomes a wider establishing shot without re-rendering the building - you simply grow the sky and foreground it needed. Second, context: a building generated in isolation gets a setting - neighbours, landscape, a foreground path - stitched believably onto what you already have, so it reads as sited rather than floating. The technique rewards patience. Extend a strip at a time - say 20 to 30% of the width per pass - so each new region has plenty of the original beside it to match perspective and light against; ask for a huge extension in one go and the far edge drifts into invention that no longer agrees with your building. Keep the overlap generous, prompt the continuation (quiet residential street, mature trees, early evening), and feather the seam. Like inpainting, outpainting is just masked denoising - the same trick pointed at the space beyond the picture rather than a hole inside it. Two patient passes usually turn a claustrophobic crop into a composed, sited image.

None of these is a one-shot button; together they're a loop, and that loop is the real design workflow. A typical pass: condition a render from your drawing (Lesson 3.3); img2img at low-to-mid strength to polish the whole thing and unify its light; inpaint to fix the two or three regions that came out wrong; outpaint to reframe or add context; then round again, feeding the improved image back in as the new starting point. Each pass keeps what works and edits only what doesn't - the exact opposite of the slot-machine re-roll you spent Lesson 3.1 fighting.

The discipline is restraint and judgement. Use the lowest denoising strength that does the job; mask tightly so you disturb only what must change; and after every step, check the result against your intent, not just its prettiness. Version as you go, too - save each pass as a numbered file, because a bold edit will sometimes go wrong, and a non-destructive history is what lets you step back a move and try another, exactly like layers and undo in any mature design tool. A concrete run might read: condition (geometry locked), img2img 0.35 (whole image polished), inpaint the ground-floor window (strength 0.5, ControlNet holding the frame), inpaint the foreground planting, outpaint the sky and street in two strips, then img2img 0.25 for a final unifying pass. Six deliberate moves, each logged, each reversible.

This is the whole promise of Module 3 delivered: from a tool that gave you a different building every time, to an instrument you can steer, correct and extend with the precision a real project demands. Conditioning set the bones; img2img polished the whole; inpainting fixed the flaws; outpainting grew the frame. String them together and you have a repeatable pipeline that carries design intent from first sketch to final image. You are no longer prompting and hoping - you are directing.

Three problems separate a clean finish from an obvious edit. The inpainted patch looks pasted on. Almost always the mask hugged the object too tightly, giving the model no surrounding context to blend against, or the masked strength ran too high. Feather the edge, include a little of the surroundings in the mask, drop the strength, and make sure the inpaint prompt matches the scene's light and material - 'warm evening light' inside a mask you filled under 'overcast' will never sit right. img2img erased something you wanted. The strength was too high for the job; step it down and run again from the previous version, not the ruined one - which is exactly why you kept numbered saves. The outpaint drifted into a different building. You extended too far in one pass; undo, take a narrower strip, and keep more overlap so the new region has your geometry to agree with.

Two rules keep the whole loop honest. First, change one variable at a time - strength, or mask, or prompt, never all three - so you always know which move helped. Second, treat every generative edit as a proposal to be checked, not a result to be trusted: overlay against your intent and reject the beautiful edit that quietly moved a real thing. Done this way the loop is genuinely non-destructive and genuinely directed - you keep the wins, discard the misses, and arrive at a finished image you can defend line by line, because you know exactly what each pass did and why.