[vtkusers] Normal vector of the surface of ellipstic cylinder
Girish Lande
girish.lande at agiliad.com
Thu Jul 27 23:11:16 EDT 2017
It may not be wrong .
I think what you have done is taken ellipse and extruded it to form
cylinder shape.
If you observe points in your polydata, they are only at the edge of
cylinder shape.
SO normals are drawn only in that region.
You have done too much scaling and hence "arrows" are mixing up to see that
graphics that you see there. I modified your code and you can see normals
drawn correctly. There is output image attached.
[image: Inline images 1][image: Inline images 2]
On 28 July 2017 at 08:15, arwtyxouymz <arw.tyx-ouy_mz at ezweb.ne.jp> wrote:
> Thank you Girish Lande!
>
> I tried to implement your code, but result is something wrong.
> Why?
> My code is below and the result is in an attachment picture.
> I want to calculat normal vectors on the side of the cylinder.
>
> please help!
>
> result.png <http://vtk.1045678.n5.nabble.com/file/n5744183/result.png>
>
> #include "vtkPoints.h"
> #include "vtkSmartPointer.h"
> #include "vtkLinearExtrusionFilter.h"
> #include "vtkDataSetMapper.h"
> #include "vtkPolyDataMapper.h"
> #include "vtkActor.h"
> #include "vtkProperty.h"
> #include "vtkCamera.h"
> #include "vtkRenderer.h"
> #include "vtkRenderWindow.h"
> #include "vtkRenderWindowInteractor.h"
> #include "vtkInteractorStyleTrackballCamera.h"
> #include "vtkPolyLine.h"
> #include "vtkLineSource.h"
>
>
> #include "vtkSphereSource.h"
> #include "vtkDoubleArray.h"
> #include "vtkFloatArray.h"
> #include "vtkCellData.h"
> #include "vtkPolyDataNormals.h"
> #include "vtkPointData.h"
> #include "vtkBrownianPoints.h"
> #include "vtkArrowSource.h"
> #include "vtkGlyph3D.h"
>
>
> bool GetPointNormals(vtkPolyData* polydata);
> void TestPointNormals(vtkPolyData* polydata);
>
> int main(int argc, char *argv[])
> {
> // 2次元楕円
> double angle = 0;
> double r1, r2;
> int id = 0;
> double CenterX, CenterY;
> r1 = 50;
> r2 = 30;
> double z_length = 50.0;
> CenterX = 0.0; CenterY = 0.0;
>
> vtkSmartPointer<vtkPoints> points =
> vtkSmartPointer<vtkPoints>::New();
> points->SetNumberOfPoints(720);
> while (angle <= 2.0 * vtkMath::Pi() + (vtkMath::Pi() / 360.0))
> {
> points->InsertPoint(id, r1 * cos(angle) + CenterX, r2 * sin(angle)
> +
> CenterY, 0);
> angle = angle + (vtkMath::Pi() / 360.0);
> id++;
> }
>
>
> vtkSmartPointer<vtkPolyLine> line =
> vtkSmartPointer<vtkPolyLine>::New();
> line->GetPointIds()->SetNumberOfIds(id);
> for (int k = 0; k < id; ++k) {
> line->GetPointIds()->SetId(k, k);
> }
>
> vtkSmartPointer<vtkCellArray> lines =
> vtkSmartPointer<vtkCellArray>::New();
> lines->InsertNextCell(line);
>
> vtkSmartPointer<vtkPolyData> polyData =
> vtkSmartPointer<vtkPolyData>::New();
> polyData->GlobalReleaseDataFlagOff();
> polyData->Allocate(1, 1);
> polyData->SetPoints(points);
> polyData->SetLines(lines);
>
> // 3次元化
> vtkSmartPointer<vtkLinearExtrusionFilter> extrude =
> vtkSmartPointer<vtkLinearExtrusionFilter>::New();
> extrude->SetInputData(polyData);
> extrude->SetExtrusionTypeToNormalExtrusion();
> extrude->SetVector(0, 0, -z_length);
> extrude->SetScaleFactor(1.0);
> extrude->Update();
>
> vtkSmartPointer<vtkPolyDataMapper> elliptic_mapper =
> vtkSmartPointer<vtkPolyDataMapper>::New();
> elliptic_mapper->SetInputConnection(extrude->GetOutputPort());
>
> vtkSmartPointer<vtkActor> elliptic_actor =
> vtkSmartPointer<vtkActor>::New();
> elliptic_actor->SetMapper(elliptic_mapper);
> elliptic_actor->GetProperty()->SetColor(0.8900, 0.8100, 0.3400);
>
> // 法線ベクトル
> vtkPolyData* elliptic_cylinder = extrude->GetOutput();
> TestPointNormals(elliptic_cylinder);
>
> vtkMath::RandomSeed(100);
> vtkSmartPointer<vtkBrownianPoints> brownianPoints =
> vtkSmartPointer<vtkBrownianPoints>::New();
> brownianPoints->SetInputConnection(extrude->GetOutputPort());
>
> vtkSmartPointer<vtkArrowSource> arrowSource =
> vtkSmartPointer<vtkArrowSource>::New();
> vtkSmartPointer<vtkGlyph3D> glyph3D =
> vtkSmartPointer<vtkGlyph3D>::New();
> glyph3D->SetSourceConnection(arrowSource->GetOutputPort());
> glyph3D->SetInputConnection(brownianPoints->GetOutputPort());
> glyph3D->SetVectorModeToUseNormal();
> glyph3D->SetScaleFactor(10.0);
>
> vtkSmartPointer<vtkPolyDataMapper> glyphMapper =
> vtkSmartPointer<vtkPolyDataMapper>::New();
> glyphMapper->SetInputConnection(glyph3D->GetOutputPort());
>
> vtkSmartPointer<vtkActor> glyphActor =
> vtkSmartPointer<vtkActor>::New();
> glyphActor->GetProperty()->SetColor(.0, 1.0, .0);
> glyphActor->SetMapper(glyphMapper);
>
>
> // 腫瘍
> double TARGET_X, TARGET_Y, TARGET_Z;
> TARGET_X = -sqrt(pow(r1, 2.0) - pow(r2, 2.0));
> TARGET_Y = 0.0;
> TARGET_Z = -z_length/2.0;
>
> vtkSmartPointer<vtkSphereSource> target =
> vtkSmartPointer<vtkSphereSource>::New();
> target->SetRadius(1.0);
> target->SetCenter(TARGET_X, TARGET_Y, TARGET_Z);
>
> vtkSmartPointer<vtkPolyDataMapper> target_mapper =
> vtkSmartPointer<vtkPolyDataMapper>::New();
> target_mapper->SetInputConnection(target->GetOutputPort());
>
> vtkSmartPointer<vtkActor> target_actor =
> vtkSmartPointer<vtkActor>::New();
> target_actor->SetMapper(target_mapper);
> target_actor->GetProperty()->SetColor(1.0, 0.0, 0.0);
>
> // ベクトル
> for (vtkIdType id= 0; id <= 720; id++)
> {
> double p[3];
> points->GetPoint(id, p);
> // 方向ベクトル
> vtkVector3d v(p[0] - TARGET_X,
> p[1] - TARGET_Y,
> p[2] - TARGET_Z);
> }
>
> // 直線
> vtkSmartPointer<vtkLineSource> lineSource =
> vtkSmartPointer<vtkLineSource>::New();
> lineSource->SetPoint1(TARGET_X, TARGET_Y, TARGET_Z);
> lineSource->SetPoint2(0.0, 0.0, 0.0);
> lineSource->Update();
>
> vtkSmartPointer<vtkPolyDataMapper> line_mapper =
> vtkSmartPointer<vtkPolyDataMapper>::New();
> line_mapper->SetInputData(lineSource->GetOutput());
>
> vtkSmartPointer<vtkActor> line_actor =
> vtkSmartPointer<vtkActor>::New();
> line_actor->SetMapper(line_mapper);
> line_actor->GetProperty()->SetLineWidth(0.5);
>
>
> // 描画
> vtkSmartPointer<vtkRenderer> ren =
> vtkSmartPointer<vtkRenderer>::New();
> vtkSmartPointer<vtkRenderWindow> renWin =
> vtkSmartPointer<vtkRenderWindow>::New();
> renWin->AddRenderer(ren);
> renWin->SetSize(600, 600);
>
> vtkSmartPointer<vtkRenderWindowInteractor> iren =
> vtkSmartPointer<vtkRenderWindowInteractor>::New();
> iren->SetRenderWindow(renWin);
>
> //ren->AddActor(line_actor);
> //ren->AddActor(target_actor);
> ren->AddActor(glyphActor);
> ren->AddActor(elliptic_actor);
> ren->SetBackground(.3, .6, .3);
>
> vtkSmartPointer<vtkInteractorStyleTrackballCamera> style =
> vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
> iren->SetInteractorStyle(style);
>
> renWin->Render();
> iren->Initialize();
> iren->Start();
>
> return EXIT_SUCCESS;
> }
>
> bool GetPointNormals(vtkPolyData* polydata)
> {
> std::cout << "In GetPointNormals: " << polydata <<
> polydata->GetNumberOfPoints() << std::endl;
> std::cout << "Looking for point normals..." << std::endl;
>
> vtkIdType numPoints = polydata->GetNumberOfPoints();
> std::cout << "There are " << numPoints << " points." << std::endl;
>
> vtkIdType numPolys = polydata->GetNumberOfPolys();
> std::cout << "There are " << numPolys << " polys." << std::endl;
>
> // Double normals in an array
> vtkDoubleArray* normalDataDouble =
>
> vtkDoubleArray::SafeDownCast(polydata->GetPointData()->
> GetArray("Normals"));
>
> if (normalDataDouble)
> {
> vtkIdType nc = normalDataDouble->GetNumberOfTuples();
> std::cout << "There are " << nc << " components in
> normalDataDouble"
> << std::endl;
> return true;
> }
>
> // Float normals in an array
> vtkFloatArray* normalDataFloat =
>
> vtkFloatArray::SafeDownCast(polydata->GetPointData()->
> GetArray("Normals"));
>
> if (normalDataFloat)
> {
> vtkIdType nc = normalDataFloat->GetNumberOfTuples();
> std::cout << "There are " << nc << " components in normalDataFloat"
> << std::endl;
> return true;
> }
>
> // Point normals
> vtkDoubleArray* normalsDouble =
>
> vtkDoubleArray::SafeDownCast(polydata->GetPointData()->GetNormals());
>
> if (normalsDouble)
> {
> std::cout << "There are " << normalsDouble->
> GetNumberOfComponents()
> << " components in normalsDouble" << std::endl;
> return true;
> }
>
> // Point normals
> vtkFloatArray* normalsFloat =
>
> vtkFloatArray::SafeDownCast(polydata->GetPointData()->GetNormals());
>
> if (normalsFloat)
> {
> std::cout << "There are " << normalsFloat->GetNumberOfComponents()
> << " components in normalsFloat" << std::endl;
> return true;
> }
>
> // Generic type point normals
> vtkDataArray* normalsGeneric = polydata->GetPointData()->GetNormals();
>
> if (normalsGeneric)
> {
> std::cout << "There are " << normalsGeneric->GetNumberOfTuples()
> << " normals in normalsGeneric" << std::endl;
>
> double testDouble[3];
> normalsGeneric->GetTuple(0, testDouble);
>
> std::cout << "Double: " << testDouble[0] << " "
> << testDouble[1] << " " << testDouble[2] << std::endl;
> return true;
> }
>
> std::cout << "Normals not found!" << std::endl;
> return false;
> }
>
>
> void TestPointNormals(vtkPolyData* polydata)
> {
> std::cout << "In TestPointNormals: " << polydata->GetNumberOfPoints()
> <<
> std::endl;
> bool hasPointNormals = GetPointNormals(polydata);
>
> if (!hasPointNormals)
> {
> std::cout << "No point normals were found. Computing normals..." <<
> std::endl;
>
> vtkSmartPointer<vtkPolyDataNormals> normalGenerator =
> vtkSmartPointer<vtkPolyDataNormals>::New();
> normalGenerator->SetInputData(polydata);
> normalGenerator->ComputePointNormalsOn();
> normalGenerator->Update();
>
> polydata = normalGenerator->GetOutput();
> hasPointNormals = GetPointNormals(polydata);
>
> std::cout << "On the second try, has point normals? "
> << hasPointNormals << std::endl;
> }
> else
> {
> std::cout << "Point normals were found!" << std::endl;
> }
> }
>
>
>
> --
> View this message in context: http://vtk.1045678.n5.nabble.
> com/Normal-vector-of-the-surface-of-ellipstic-cylinder-
> tp5744171p5744183.html
> Sent from the VTK - Users mailing list archive at Nabble.com.
> _______________________________________________
> Powered by www.kitware.com
>
> Visit other Kitware open-source projects at http://www.kitware.com/
> opensource/opensource.html
>
> Please keep messages on-topic and check the VTK FAQ at:
> http://www.vtk.org/Wiki/VTK_FAQ
>
> Search the list archives at: http://markmail.org/search/?q=vtkusers
>
> Follow this link to subscribe/unsubscribe:
> http://public.kitware.com/mailman/listinfo/vtkusers
>
--
thanks & regards,
Girish
--
------------------------------------------------------------
-------------------------------------------------------------
*Disclaimer:* This email message including any attachments is confidential,
and may be privileged and proprietary to Agiliad. If you are not the
intended recipient, please notify us immediately by replying to this
message and destroy all copies of this message including any attachments.
You are NOT authorized to read, print, retain, copy, disseminate,
distribute, or use this message or any part thereof. Thank you.
------------------------------------------------------------
------------------------------------------------------------
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://public.kitware.com/pipermail/vtkusers/attachments/20170728/cbaa06bd/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 1.png
Type: image/png
Size: 62613 bytes
Desc: not available
URL: <http://public.kitware.com/pipermail/vtkusers/attachments/20170728/cbaa06bd/attachment-0002.png>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 2_zoom.png
Type: image/png
Size: 55558 bytes
Desc: not available
URL: <http://public.kitware.com/pipermail/vtkusers/attachments/20170728/cbaa06bd/attachment-0003.png>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: normals_at_each_point_in_cylinder.cpp
Type: text/x-c++src
Size: 8957 bytes
Desc: not available
URL: <http://public.kitware.com/pipermail/vtkusers/attachments/20170728/cbaa06bd/attachment-0001.cpp>
More information about the vtkusers
mailing list