well the base3d class says that
scale_factor has different meanings for different cameras. For the Arcball and Turntable they say scale_factor represents the zoom level so I would assume that anything less than 1 is just "closer" to the center point. I feel like I've seen one of these cameras used to look past the center point before, but not sure if that involved a negative scale factor or not. I'm sure I don't understand what's going on here as much as I should to properly participate in this discussion. I'd say if you feel strongly about this then maybe make a PR or at least an issue. It'll be easier to pull others into the discussion
@almarklein @rougier Any idea if the PolarTransform in vispy is able to support going all the way around: https://stackoverflow.com/questions/68177737/how-to-convert-visuals-image-to-polar-using-vispy
So the PolarTransform which I've tweaked a bit only works because my arrays consist of 360 deg in theta dimension. If less you get only parts of the circle and if more it gets overplotted. I remember that I didn't find a possibility to somehow normalize sizes/positions.
glsl_imap = """
vec4 polar_transform_map(vec4 pos) {
float theta = atan(pos.y, pos.x);
theta = degrees(theta) + 180;
float r = length(pos.xy);
return vec4(theta, r, pos.z, 1);
}
"""
This gets
theta in degrees between (0, 360). The r value is evaluated correct so far I can tell from my output.
Upper left, the image as is. The other four are the four polar representations, when one side is "collapsed" to the center. You see the two left (size=360) it works nicely. On the right side (size=180) only half is displayed. I would need somehow have access to the
image_size to normalize it to 360deg but this seems not accessible from the glsl_map function. Any ideas? Otherwise we could advertise this workaround, but a real solution would be better.
Unfortunately I can't get it working without having the the size of dimension over which the image is "collapsed" to the center at 360. Somehow, the PolarTransform needs prior knowledge of the visual (ImageVisual) sizes and orientation to correctly normalize. Maybe we will be happier with a PolarImage? So, if any of you can point me into the right direction, I very much appreciate it.
import numpy as np
import vispy.app
from vispy import gloo
from vispy import visuals
from vispy.visuals.transforms import (MatrixTransform, STTransform,
PolarTransform)
class MyPolarTransform(PolarTransform):
glsl_map = """
vec4 polar_transform_map(vec4 pos) {
return vec4(pos.y * cos(pos.x), pos.y * sin(pos.x), pos.z, 1.);
}
"""
glsl_imap = """
vec4 polar_transform_map(vec4 pos) {
float theta = atan(pos.y, pos.x);
//theta = theta + 3.14159265358979323846;// + 180;
theta = degrees(theta) + 180;
float r = length(pos.xy);
return vec4(theta, r, pos.z, 1);
}
"""
class Canvas(vispy.app.Canvas):
def __init__(self):
csize = 360 * 3
vispy.app.Canvas.__init__(self, keys='interactive', size=(csize, csize))
# Create image
image = np.ones((360, 360, 3), dtype=np.uint8)
grad = np.linspace(0, 255, 360, dtype=np.uint8)[None, :, None]
image *= grad
image[:, 310:360, :] = 0
image[5:40] = 255
image[:, 10:50, :] = 255
#image = np.swapaxes(image, 0, 1)
image2 = image
self.images = [visuals.ImageVisual(image, method='impostor') for i in range(4)]
self.images2 = [visuals.ImageVisual(image2, method='impostor') for i in range(4)]
for i, im in enumerate(self.images):
tx = 0
ty = 0
if i == 1:
tx = self.images[0].size[1]
xoff = csize / 4 * 3
yoff = csize / 4
elif i == 2:
tx = self.images[0].size[0]
ty = self.images[0].size[1]
xoff = csize / 4
yoff = csize / 4 * 3
elif i == 3:
ty = self.images[0].size[0]
xoff = csize / 4 * 3
yoff = csize / 4 * 3
else:
xoff = csize / 4
yoff = csize / 4
r0 = MatrixTransform()
off = i * 90
r0.rotate(off, (0, 0, 1))
roti = (
STTransform(translate=(tx, ty, 0)) *
r0
)
tr1 = (STTransform(scale=(0.5, 0.5, 1), translate=(xoff, yoff, 0)) *
#r0 *
MyPolarTransform() *
roti
)
tr2 = (STTransform(scale=(1.0, 1.0, 1), translate=(xoff-csize/4, yoff-csize/4, 0)) #*
)
self.images[i].transform = tr1
self.images2[i].transform = tr2
self.visuals = [*self.images, *self.images2]
self.show()
def on_draw(self, ev):
gloo.clear(color='w', depth=True)
for vis in self.visuals:
vis.draw()
def on_resize(self, event):
# Set canvas viewport and reconfigure visual transforms to match.
vp = (0, 0, self.physical_size[0], self.physical_size[1])
self.context.set_viewport(*vp)
for vis in self.visuals:
vis.transforms.configure(canvas=self, viewport=vp)
if __name__ == '__main__':
win = Canvas()
import sys
if sys.flags.interactive != 1:
vispy.app.run()
Simple example showing a window with divided into 4 squares. Each square shows the original image and on top it's PolarTransformed representation. (UL- top is center, UR left is center, LL - bottom is center, LR - right is center. As you can see, somehow x and y axes are inverted for the Transformed representation. This makes me a bit nervous as this means that somewhere something fishy is going on (or I do not understand it yet). If you swap pos.x/pos.y in the atan-call in glsl_imap the output is correct, but then the atan function uses inverted coordinates. I'm not sure where the problem lies. So in case it is in front of the screen, please let me know.
BTW, working with latest github main branch.
What am I missing?
vispy is 0.4.0
I will upgrade vispy and check
Hi there! Great job on 0.7.0! I have a quick question re
Volumes: is there a straight forward way to scale them? For example, I would like each voxel to have a isometric (or perhaps even non-isometric) size for easier co-visualization with other data. Perhaps with some kind of transform?
2 replies
@ViNOJ-DAViS Please have a look here: vispy/vispy#2133 If we can add tests to this, this might go in for version 0.8.0 (next month)
@ViNOJ-DAViS While you are here, I've added a new example here, which fiddles with the polar transform ( https://github.com/vispy/vispy/pull/2133#issuecomment-879854314)
@ViNOJ-DAViS To put even more detail on that: RGBA stands for Red, Green, Blue, Alpha where RGB are your normal image data making up the multi-color image and Alpha controls the transparency of the image where the lowest value (0) is fully transparent and the highest value (1 or 255 depending on data type) is fully opaque
@kmuehlbauer I am testing vispy/vispy#2133 with some test data
Please have a look at my last example without that PR. That will do what you want without any changes to imsgevisual
For this code ( https://github.com/vispy/vispy/pull/2133#issuecomment-879854314 )
I've found an issue with the "direction" cw/ccw but no issue with the location.
In the above image you see the original image (top left) and the polar representation (center). For the polar representation the original image is spread over 360 deg from left to right, with range=0 at the top and range=max at the bottom in clockwise fashion.
The image above shows the polar representation, from left to right, when r=max at the top and r=0 at the bottom.
