## trace – bombine points in 3D space by ListPointPlot3D

I have a matrix and I want to trace it in 3d space by `ListPointPlot3D` function.

``````list = {{1, 2, 3, 4, 5}, {2, 2, 2, 2, 2}};
ListPointPlot3D[list]
``````

The result is as follows

But I want the two dotted lines combined.

If you plot in 2d space, it works well for `ListPlot`, but I do not know how to solve it in 3D space.

## 2D Platformer in a 3D first person?

I am a beginner in the creation / programming / development of games and I want to know if it is possible to change from a Platformer 2D to the 3D Platformer in the SAME GAME? My idea is that you start in a 2D platform game (possibly 8 bits) like Mario. Then, halfway, the game. SWITCHES in a 3D first person platform game where you PLAY as the type you controlled on the screen. So my question is …

"Is that possible?"

## Awesome cartoon 3D character characters and 3D character animation for \$ 50

I can do character modeling in 3D in the form of printing 3D characters, 3D animated characters and complex 3D characters for you.

by: bangaakzhey
Created: –
Category: Art and Design
Views: 186

.

## tracing – Parameterization of the limit curve in 3D Plot

I am considering a function of the form:

u0 = p[1](Q1[1] – K1) / (p[1] – K1 + Sqrt[(K1)^2 – m1^2](1 – 2 * alpha));

With P[1], Q1[1], and m1 being constant (set p[1] = 1, Q1[1] = 1/2, m1 = 0.1). Therefore, I am considering u0 as a function of K1 and alpha. Due to physical constraints, I want my u0 to be between the values ​​4/9 and 0.48, while K1 could be between 0.1 and 1/2 and alpha between 1/2 and 1. One can easily verify that the domain for K1 and alpha They are too large to ensure that u0 is between 4/9 and 0.48 when checking the above equation. Therefore, I need to restrict alpha or K10 so that u0 is always in my desired domain. A plot could be something revealing:

Plot3D[u0Max3*0.48, {K1, 0.1, 1/2}, {alpha, 1/2, 1}, PlotRange -> {4/9, 0.48}];

Ultimately, my goal is to integrate this volume with numerical procedures like NIntegrate or Vegas, but for this I need to establish the domain of the variables. So I'm looking for a way to get a functional dependency between alpha and K1, so that I can integrate this and get the right volume.

## Movement of the 3D player with the new Unity input system.

So, I'm trying to get used to the new Unity entry system. "Back in the days" I just got the Vertical / Horizontal axis, I put them in a Vector3, I multiplied them by a certain value and then I moved the player.

Now, with the new entry system, that changed a bit. So, what I'm trying to do is get the input of a 2D Vector, formerly called DPAD in the new system. My focus was, how

``````empty private Awake () {
InputAction.performed + = ctx => Motion (ctx.ReadValue());
InputAction.canceled + = ctx => Motion (ctx.ReadValue());
}

Empty private OnMovement (Vector2 _dir) {
moveDirection = _dir;
}

// This was done in FixedUpdate
Private void Move () {
transform.position + = moveDirection * moveSpeed ​​* Time.deltaTime;
}
``````

Buut, you know, something worked, but not really. The player did involuntary things like keep moving or not react at all to my button by pressing. Maybe I fixed something wrong. Could you please help me, thank you!

## How to use the known projection matrices of the cameras to generate a new fundamental matrix correctly located in 3D space?

I have some cameras that have been calibrated (using a chessboard), so I know the fundamental matrix between a source camera and each remaining camera

I want to take pairs of cameras without a fundamental matrix, but each one has a projection matrix, and calculate the fundamental matrix with the view to reconstruct the stereo pair in 3D. To clarify, since all cameras have a projection matrix, I should be able to take any combination and generate a Fundamental matrix, so I can reconstruct and combine stereo pairs in 3D using as many pairs as possible

I currently use this formula:

(decomposing the projection matrices of the camera to obtain C)

but that did not work well with stereo pairs that do not include the source. I noticed that to calculate the fundamental matrix that rotation was relative so I added the relative rotation formula to recalculate P of K / R / T (intrinsic camera parameters, rotation matrix, translation matrix)

but now every reconstruction appears in the position of the camera (I think) instead of all the stereo pairs being assigned in the same space to give a dense reconstruction

Does anyone know what I'm doing wrong? Thanks for any help

## Drag the 3D camera with the mouse cursor

I have a camera that moves by changing its X and Z coordinates. However, the camera is rotated, so when an object moves 1 unit in the world, the amount of pixels it moves around is not trivial to determine.

How could I move the camera so that if the pointer is at a set point, that point will be below the cursor after the cursor moves?

## Performance adjustment – efficient ListConvolve on 3D matrix

I am trying to find an efficient way to apply the convolution of lists to a 3d matrix of 0 and 1, where approximately 5% of the matrix is ​​1, but the 1 can be placed randomly or grouped into a large contiguous "island" ( note that this is related to a separate question I asked here about more efficient ways to generate this matrix).

Essentially I want to convert a set of small cores (3x3x3) with this large matrix of 1s and 0s. I have an implementation (see below), but I wonder if there is a smarter way to take advantage of the sparse nature of my matrix; the fact that the 1 is placed at random makes this difficult.

Ultimately, my goal in doing this is to count the number of "interactions of three neighbors" (that is, the number of interactions 1-1-1, 1-1-0, 1-0-0 and 0-0- 0) in the matrix, where these interactions could have an arbitrary geometry specified by the 3x3x3 kernel. I have tried to think if there would be a more efficient way to implement this through the encoding of the matrix as a graph of some kind, but I am not familiar enough with that infrastructure in Mathematica to make much progress. Any help or advice to optimize this calculation would be greatly appreciated.

The work code: given a large but scattered three-dimensional matrix, M (which I create here through GrowRandArray), and a set of small 3x3x3 cores (here randomly selected from all possible 3x3x3 permutations of binary matrices with 3 1s), there is a more efficient way to implement "GetCounts" below:

``````GrowRandArray[percent_, size_] : = Module[{locs, phaseb, phase},
locs = Flatten[
Table[{i, j, k}, {i, 1, size}, {j, 1, size}, {k, 1, size}], two];
phaseb = RandomSample[locs, Ceiling[percent*size^3]];
phase =
SparseArray[
phaseb -> ConstantArray[1, Length[phaseb]], {size, size, size}]](* this is only to generate the large matrix for this example *)

GetCounts[Mat_, kernels_, num_] : =
Tell[Flatten[ListConvolve[#, Mat, 1] & / @ kernels], #]& / @
Distance[0, num];

M = GrowRandArray[0.1, 30];
kernelsFull =
ArrayReshape[#, {3, 3, 3}] & / @
Permutations[{1, 1, 1}~Join~ConstantArray[0, 3^3 - 3]];
kernels = RandomSample[kernelsFull, 20];
GetCounts[M, kernels, 3]
``````

## tracing – Insert multiple lines at certain places in a 3D plot

``````data = table[{x, y, Cos[x] Sin[y]}, {x, 0, π, 0.1}, {y, 0, 2 π, 0.2}];

lines = Graphics3D[{Red, Thick, Line[{{Pi, #, -1}, {Pi, #, 1}}] & / @ {2, 3, 5}}];
Show[ListPlot3D[Flatten[data, 1]], lines]
``````

Alternatively, you can use `FaceGrids` Y `Face style`:

``````ListPlot3D[Flatten[data, 1],
FaceGrids -> {{{1, 0, 0}, {{2, 3, 5}, {}}}},
FaceGridsStyle -> Directive[Red, Thick]]
``````