Got to fix some things next week. I'm learning as I go here, butwikipedia says that an orthographic projection (ie parallel light rays) happens when you have an infinite focal length along with an infinite view distance. So I think it makes physical sense to only have the single projection function, and for set_proj_type('ortho'), simply have this set the focal distance to infinity. Then check for infinity in persp_transformation and break it out to ortho_transformation if needed for the numerics.

An argument against this would be if we wanted to add oblique projections such as are used in some realms of drafting, but I think that's a little out of scope for now.

Basic functionality is working now, check out the comparison plot (still a bit of a wip):

I'm a little conflicted on whether to do input range checking for the focal length. The focal_length=0 is a (in reality as well as in code) degenerate case, but I'm not sure errors here should be blocking. The negative focal lengths essentially rotate the camera location 180 deg about the horizontal view line. A physical camera will never have a negative focal length, but maybe there's a use case for it?

A focal length of -np.inf is also a weird edge case to handle, since we'd have to do some transforms before passing it to the orthographic projection function.

I don't think there is a compelling case to keep negative focal lengths if the same effect can be achieved with a positive focal length and a twist. It just seems like it will confuse folks.

The failed tests are only the ones identified in#22076, and aren't related to this PR.

This is good to go, here's the new gallery image:

@QuLogic The real proof of the pudding is in the output plots since the "correctness" of the projection matrices depends on the rest of our implementation. IMO the new test image with a few focal lengths is enough to test that code path.

We have at least two datapoints that we can look at within matplotlib to confirm that it's working as intended: plots which match the existing focal length of 1, and plots which approach the orthographic projection as the focal length goes to large numbers (I can't spot a visual difference between ortho and focal_length=1000). There is also the qualitative behavior that the plot "deepens" as it approaches 0, and starts to blow up as expected for very small focal lengths (on the order of <0.01).

It would be nice to test the math directly, but I don't know of canonical projection matrices for certain values that we can compare against. Certainly we can see that it matches what's expected by inspection (below). Other implementations have had OpenGL as a baseline renderer to compare pixels against (seebottom of this page), but we don't have that capability.

@WeatherGod you have a block on this - I think its pretty close, so can you take a second look?

Sweet, added tests and addressed those comments.