CT Slices to Planar XRay
I think that what you are looking for is a maximum intensity projection (MIP).
The general approach has two parts:

Define the view
Obtain the projection

To define the view, you need to either rotate the data in-place or rotate the view plane around the data and then use the coefficients of the plane to read through your data matrix. In either case, you are going to need interpolation.
The most straightforward way to do this is to rotate the data in-place.
If you are interested in obtaining just the three principal views, you don't even need to rotate the data.
Let's assume that you have a matrix like $(y,x,z)$. That is, each axial image's data is in $(y,x)$ and each slice's axial image can be accessed via $z$.
Since these are the axial images, looking at an individual $(y,x)$ image is like looking through our volume from the top. So, we are looking at $(y,x)$ down through $z$.
To obtain an &quot;X-Ray-like&quot; image of the volume as is, all you have to do is iterate through each $(y,x)$ pixel, get all the pixel values that &quot;live&quot; in that column (so, get all the pixel values at location $(y,x)$ from slice $0,1,2,3,..,N$) and select the maximum value from that column. Then move to the next pixel and so on.
This will give you the MIP in the axial direction. To obtain the MIP from another point of view, all you have to do is to rotate your volume to align it with the view and run the same iteration through the image again.
In the special case where you only need the three principal directions, you don't even need to rotate the data, you just change the way you are reading it: Where before we were looking at $(y,x)$ down through $z$ for the axial view, we now need to look at $(y,z)$ down through $x$ for the sagital view...and so on.
Here is a quick example in Python (but generalisable easily to other platforms too):
import numpy
from matplotlib import pyplot as plt

# We need some data, so let's build a phantom.
# This is a sphere that is harded in the middle and contains 
# a rectangular block.

v = numpy.zeros((10,10,10)) # This is the size of our phantom

for m in range(0,10):
    for n in range(0,10):
        for k in range(0,10):
            # This is basically the a reversed distance plus a dense rectangular block running through it.
            v[m,n,k]= 20-numpy.sqrt((m-5)**2+(n-5)**2+(k-5)**2) + (10 if m&gt;3 and n&gt;3 and k&gt;2 and m&lt;6 and n&lt;6 and k&lt;8 else 0)


# To get the axial MIP:

z = numpy.zeros((10,10)) # Notice this is a single image, NOT a stack

for m in range(0,10):
    for n in range(0,10):
        z[m,n]=numpy.max(v[m,n,:])

plt.imshow(z);plt.show()

And this will give you something like:

This is a MIP of the axial view, so looking at our volume from the top.
To look at our volume &quot;from the side&quot; (the sagital view), we just change the way we read the volume:
# To get a sagital view MIP:

for m in range(0,10):
    for n in range(0,10):
        z[m,n]=numpy.max(v[m,:,n])

plt.imshow(z);plt.show()


And this will give you something like:

Notice here that the $x$ axis of this image is the $z$ axis of the volume.
To obtain any other view, simply 3D rotate the data in your v to align it to the view plane and then run the z iteration again for the MIP.
You can see here that if the pixel size and slice thickness are not equal, then the sagital view will appear distorted.
If you are looking for a library to achieve this, you can use something like vtk, although, be aware that it requires some level of prior experience to use it and more overhead to get an example up and running.
Hope this helps.