trouver l'emplacement entre deux autres emplacements

Question

J'essaie d'essayer de trouver un nouvel emplacement (x, y, z) entre deux emplacements déjà existants (x, y, z).

par exemple. disons que la distance entre locA et locB est 2500. locNew devrait toujours être l'emplacement avec la distance 300 et devrait être sur la ligne de locA et de locB.

Je n'ai aucun problème à trouver le point milieu entre locA et locB, mais je continue de me taper la tête en essayant de trouver locNew pour cette situation spécifique.

J'ai essayé, mais il retourne un point qui ne figure pas sur la ligne de Loca à locB:

locA = {x = 400, y = 400, z = 400} 
locB = {x = 1200, y = 1200, z = 1200} 

--this is wrong somehow 
locNew_x = (locB.x+locA.x)-(locB.x-300) 
locNew_y = (locB.y+locA.y)-(locB.y-300) 
locNew_z = (locB.z+locA.z)-(locB.z-300) 
locNew = {x = locNew_x, y = locNew_y, z = locNew_z} 

--draws a line between two objects 
DrawLine(locA, locNew) 

langue de codage n'est pas important, étant donné que le calcul devrait ressembler à « presque » la même chose dans la plupart des langues , gardez à l'esprit que je suis à la recherche d'une solution sous une forme non mathématique.

Mise à jour: Les solutions standard fonctionnent si x, y, z sont identiques, mais pas si elles sont différentes comme dans l'exemple ci-dessous.

locA = {x = 1475, y = 95, z = 838} 
locB = {x = 2226, y = 110, z = 1190} 

Answer 1

Je pense que cela pourrait vous aider:

-- Substract vectors 
function subVectors(vector_A, vector_B) 
    return {x = (vector_A.x - vector_B.x), 
      y = (vector_A.y - vector_B.y), 
      z = (vector_A.z - vector_B.z)} 
end 

--- Calculate length of vector 
function vectorLength(vector_A) 
    return math.sqrt(
     (vector_A.x * vector_A.x) + 
     (vector_A.y * vector_A.y) + 
     (vector_A.z * vector_A.z) 
    ) 
end 

-- Convert to unit vector 
function toUnitVector(vector_A) 
    local ln = vectorLength(vector_A) 
    return {x = (vector_A.x/ln), y = (vector_A.y/ln), z = (vector_A.z/ln)} 
end 

-- calculate position of vector which is on the line between A and B and 
-- its distance from B point equals `distance` 
function distancedVector(vector_A, vector_target, distance) 
    local vec = subVectors(vector_A, vector_target) 
    local unitVec = toUnitVector(vec) 

    return { 
     x = (vector_target.x + unitVec.x * distance), 
     y = (vector_target.y + unitVec.y * distance), 
     z = (vector_target.z + unitVec.z * distance) 
    } 
end 

local locA = {x = 0.0, y = 0.0, z = 0.0} 
local locB = {x = 900.0, y = 900.0, z = 900.0} 

local ret = distancedVector(locA, locB, 10) 

print(string.format("x: %f\ny: %f\nz: %f\n", ret.x, ret.y, ret.z)) 

sortie:

x: 894.226497 
y: 894.226497 
z: 894.226497 

connexes: Move point to another in c#

Answer 2

Je crois que cela devrait fonctionner:

locA = {x = 400, y = 400, z = 400} 
locB = {x = 1200, y = 1200, z = 1200} 

scalar = 300/distance(locA,locB); --target distance/existing distance 

locNew_x = locA.x + (locB.x - locA.x) * scalar 
locNew_y = locA.y + (locB.y - locA.y) * scalar 
locNew_z = locA.z + (locB.z - locA.z) * scalar 
locNew = {x = locNew_x, y = locNew_y, z = locNew_z} 


DrawLine(locA, locNew) 

Désolé si cela ne répond pas à votre question, je ne sais pas exactement ce que vous entendez par « une forme non mathématique »