Donald Trump ist von der Arbeit der Leute auf dieser Seite sehr beeindruckt. Er hat gesehen, wie großartig es war, dass Sie Ben Carson geholfen haben , und hat Sie sogar beauftragt , seine Mauer zu bauen . Er findet dich großartig. Jetzt braucht er wieder deine Hilfe. Während er erfolgreich seine Mauer gebaut hat, braucht er jetzt die mexikanische Regierung, um dafür zu bezahlen. Er will eine Million Dollar pro Meile in Rechnung stellen und er hat ihnen gesagt, dass die Grenze zwischen den USA und Mexiko 1.989 Meilen lang ist . Sie sind sich jedoch nicht sicher, ob diese Zahl korrekt ist, und möchten daher auch eine maßstabsgetreue visuelle Darstellung. Hier kommst du rein. Du sollst diese Karte nehmen:

und für jede n (50 <= n <= 500) Meilen an der Grenze eine Linie mit einer Länge von 25 Pixeln senkrecht zur Neigung der Grenze an diesem Punkt zeichnen. Anhand des Maßstabs auf der rechten Seite der Karte habe ich festgestellt, dass 100 Meilen ~ 50 Pixel sind . Ich habe ein Beispiel der ersten 3 Linien für n = 60 gezeichnet, aber dies sind nur ungefähre Angaben:

Anmerkungen:

• Die einzige Eingabe ist n . Die Ausgabe sollte das Kartenbild sein, mit den hinzugefügten Linien, auf dem Bildschirm gezeichnet oder in einer Rasterbilddatei gespeichert (Sie können die ursprüngliche Kartendatei überschreiben).
• Sie können die leere Zuordnungsdatei unter einem beliebigen Dateinamen speichern. Es ist ein JPEG, aber Sie können es in ein anderes gängiges Rasterformat konvertieren, wenn Sie es vorziehen. Sie können das Bild auch um bis zu 50% verkleinern, solange Sie die Abmessungen proportional halten und Ihre Linien immer noch maßstabsgetreu sind.
• Jede Linie sollte an diesem Punkt senkrecht zur Neigung des Randes stehen. Die Steigung sollte von 50 Meilen vor dem Punkt bis 50 Meilen nach dem Punkt berechnet werden.

Richtigkeit:

• Die Steigung jeder Linie kann eine Fehlertoleranz von ± 5 ° haben
• Der Abstand zwischen den einzelnen Linien kann eine Fehlertoleranz von ± 20 Meilen (10 Pixel auf der regulären Karte) haben.

Python 2 + Numpy + OpenCV , 576 Bytes

from cv2 import*
from numpy import*
n=input()/4
f="m.png"
i=imread(f)
b=array([0]*3)
y=array([165,195,225])
j=inRange(i,b,b+120)
k=inRange(i,y,y+25)
for x,y in zip(*where(j)):j[x,y]=k[x+3,y]-j[x+1,y]>1
j=j[506:732,152:557]
p=[array([11,9])]
for c in sorted(zip(*where(j)),key=lambda c:c[1]):r=range(p[-1][1]+1,c[1]+1);p+=map(array,zip(map(int,interp(r,*zip(p[-1],c)[::-1])),r))
for x,c in enumerate(p[25:-25:n]):s=-1/true_divide(*p[x*n+50]-p[x*n+25]);k=6/(1+s**2)**.5;line(i,*map(tuple,[(c+[int(k*s)+506,int(k)+152])[::-1],(c-[int(k*s)-506,int(k)-152])[::-1],b]))
imwrite(f,i)

Dieses Programm ist fast gänzlich ungolfed und es gibt Aspekte, die im Moment etwas ungenau sind, aber zumindest zum größten Teil funktionieren. Zusätzlich gibt es eine kleines bisschen von Hardcoding, aber es ist nur ein ungefähres Fenster der Grenze umschließt und die Koordinate des ersten Pixels an der Grenze (letztere von denen ich eigentlich sehr wahrscheinlich später entfernen).

Das vom Programm verwendete Bild wird in der Fläche halbiert (dh 1120 x 865), sodass die Länge der gezeichneten Linien und der Abstand zwischen den Linien kleiner ist.