コード例 #1
0
def addCartesianCoordinates(
        ugrid,
        verbose=1):

    myVTK.myPrint(verbose, "*** addCartesianCoordinates ***")

    points = ugrid.GetPoints()
    (farray_xx,
     farray_yy,
     farray_zz) = computeCartesianCoordinates(
        points=points,
        verbose=verbose-1)

    ugrid.GetPointData().AddArray(farray_xx)
    ugrid.GetPointData().AddArray(farray_yy)
    ugrid.GetPointData().AddArray(farray_zz)

    cell_centers = myVTK.getCellCenters(
        mesh=ugrid,
        verbose=verbose-1)
    (farray_xx,
     farray_yy,
     farray_zz) = computeCartesianCoordinates(
        points=cell_centers,
        verbose=verbose-1)

    ugrid.GetCellData().AddArray(farray_xx)
    ugrid.GetCellData().AddArray(farray_yy)
    ugrid.GetCellData().AddArray(farray_zz)
def addPseudoProlateSpheroidalCoordinatesAndBasisToBiV(
        ugrid,
        pdata_endLV,
        pdata_endRV,
        pdata_epi,
        verbose=1):

    myVTK.myPrint(verbose, "*** addPseudoProlateSpheroidalCoordinatesAndBasisToBiV ***")

    (farray_rr,
     farray_cc,
     farray_ll,
     farray_eRR,
     farray_eCC,
     farray_eLL) = computePseudoProlateSpheroidalCoordinatesAndBasisForBiV(
        points=ugrid.GetPoints(),
        iarray_regions=ugrid.GetPointData().GetArray("region_id"),
        farray_c=ugrid.GetPointData().GetArray("c"),
        farray_l=ugrid.GetPointData().GetArray("l"),
        farray_eL=ugrid.GetPointData().GetArray("eL"),
        pdata_endLV=pdata_endLV,
        pdata_endRV=pdata_endRV,
        pdata_epi=pdata_epi,
        iarray_part_id=ugrid.GetPointData().GetArray("part_id"),
        verbose=verbose-1)
    ugrid.GetPointData().AddArray(farray_rr)
    ugrid.GetPointData().AddArray(farray_cc)
    ugrid.GetPointData().AddArray(farray_ll)
    ugrid.GetPointData().AddArray(farray_eRR)
    ugrid.GetPointData().AddArray(farray_eCC)
    ugrid.GetPointData().AddArray(farray_eLL)

    cell_centers = myVTK.getCellCenters(
        mesh=ugrid,
        verbose=verbose-1)
    (farray_rr,
     farray_cc,
     farray_ll,
     farray_eRR,
     farray_eCC,
     farray_eLL) = computePseudoProlateSpheroidalCoordinatesAndBasisForBiV(
        points=cell_centers,
        iarray_regions=ugrid.GetCellData().GetArray("region_id"),
        farray_c=ugrid.GetCellData().GetArray("c"),
        farray_l=ugrid.GetCellData().GetArray("l"),
        farray_eL=ugrid.GetCellData().GetArray("eL"),
        pdata_endLV=pdata_endLV,
        pdata_endRV=pdata_endRV,
        pdata_epi=pdata_epi,
        iarray_part_id=ugrid.GetCellData().GetArray("part_id"),
        verbose=verbose-1)
    ugrid.GetCellData().AddArray(farray_rr)
    ugrid.GetCellData().AddArray(farray_cc)
    ugrid.GetCellData().AddArray(farray_ll)
    ugrid.GetCellData().AddArray(farray_eRR)
    ugrid.GetCellData().AddArray(farray_eCC)
    ugrid.GetCellData().AddArray(farray_eLL)
コード例 #3
0
def addRegionsToBiV(ugrid_mesh, pdata_endLV, pdata_endRV, pdata_epi, verbose=0):

    myVTK.myPrint(verbose, "*** addRegionsToBiV ***")

    points = ugrid_mesh.GetPoints()
    iarray_region = computeRegionsForBiV(
        points=points, pdata_endLV=pdata_endLV, pdata_endRV=pdata_endRV, pdata_epi=pdata_epi, verbose=verbose - 1
    )
    ugrid_mesh.GetPointData().AddArray(iarray_region)

    cell_centers = myVTK.getCellCenters(mesh=ugrid_mesh, verbose=verbose - 1)
    iarray_region = computeRegionsForBiV(
        points=cell_centers, pdata_endLV=pdata_endLV, pdata_endRV=pdata_endRV, pdata_epi=pdata_epi, verbose=verbose - 1
    )
    ugrid_mesh.GetCellData().AddArray(iarray_region)
コード例 #4
0
def addPDataNormals(
        pdata,
        orient_outward=1,
        verbose=0):

    myVTK.myPrint(verbose, "*** addPDataNormals ***")

    poly_data_normals = vtk.vtkPolyDataNormals()
    poly_data_normals.ComputePointNormalsOff()
    poly_data_normals.ComputeCellNormalsOn()
    if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
        poly_data_normals.SetInputData(pdata)
    else:
        poly_data_normals.SetInput(pdata)
    poly_data_normals.Update()
    pdata = poly_data_normals.GetOutput()

    if (orient_outward):
        cell_centers = myVTK.getCellCenters(
            mesh=pdata,
            verbose=verbose-1)
        cell_center = numpy.empty(3)

        mesh_center = numpy.array(pdata.GetCenter())

        normals = pdata.GetCellData().GetNormals()
        normal = numpy.empty(3)

        cnt_pos = 0
        cnt_neg = 0
        for k_cell in xrange(pdata.GetNumberOfCells()):
            cell_centers.GetPoint(k_cell, cell_center)
            outward  = cell_center-mesh_center
            outward /= numpy.linalg.norm(outward)
            normals.GetTuple(k_cell, normal)
            proj = numpy.dot(outward, normal)
            if (proj > 0): cnt_pos += 1
            else:          cnt_neg += 1
        #print cnt_pos
        #print cnt_neg

        if (cnt_neg > cnt_pos):
            poly_data_normals.FlipNormalsOn()
            poly_data_normals.Update()
            pdata = poly_data_normals.GetOutput()

    return pdata
def addPseudoProlateSpheroidalCoordinatesAndBasisToBiV(ugrid,
                                                       pdata_endLV,
                                                       pdata_endRV,
                                                       pdata_epi,
                                                       verbose=0):

    myVTK.myPrint(
        verbose, "*** addPseudoProlateSpheroidalCoordinatesAndBasisToBiV ***")

    (farray_rr, farray_cc, farray_ll, farray_eRR, farray_eCC,
     farray_eLL) = computePseudoProlateSpheroidalCoordinatesAndBasisForBiV(
         points=ugrid.GetPoints(),
         iarray_regions=ugrid.GetPointData().GetArray("region_id"),
         farray_c=ugrid.GetPointData().GetArray("c"),
         farray_l=ugrid.GetPointData().GetArray("l"),
         farray_eL=ugrid.GetPointData().GetArray("eL"),
         pdata_endLV=pdata_endLV,
         pdata_endRV=pdata_endRV,
         pdata_epi=pdata_epi,
         iarray_part_id=ugrid.GetPointData().GetArray("part_id"),
         verbose=verbose - 1)
    ugrid.GetPointData().AddArray(farray_rr)
    ugrid.GetPointData().AddArray(farray_cc)
    ugrid.GetPointData().AddArray(farray_ll)
    ugrid.GetPointData().AddArray(farray_eRR)
    ugrid.GetPointData().AddArray(farray_eCC)
    ugrid.GetPointData().AddArray(farray_eLL)

    cell_centers = myVTK.getCellCenters(mesh=ugrid, verbose=verbose - 1)
    (farray_rr, farray_cc, farray_ll, farray_eRR, farray_eCC,
     farray_eLL) = computePseudoProlateSpheroidalCoordinatesAndBasisForBiV(
         points=cell_centers,
         iarray_regions=ugrid.GetCellData().GetArray("region_id"),
         farray_c=ugrid.GetCellData().GetArray("c"),
         farray_l=ugrid.GetCellData().GetArray("l"),
         farray_eL=ugrid.GetCellData().GetArray("eL"),
         pdata_endLV=pdata_endLV,
         pdata_endRV=pdata_endRV,
         pdata_epi=pdata_epi,
         iarray_part_id=ugrid.GetCellData().GetArray("part_id"),
         verbose=verbose - 1)
    ugrid.GetCellData().AddArray(farray_rr)
    ugrid.GetCellData().AddArray(farray_cc)
    ugrid.GetCellData().AddArray(farray_ll)
    ugrid.GetCellData().AddArray(farray_eRR)
    ugrid.GetCellData().AddArray(farray_eCC)
    ugrid.GetCellData().AddArray(farray_eLL)
def addCylindricalCoordinatesAndBasis(
        ugrid,
        points_AB,
        verbose=0):

    myVTK.myPrint(verbose, "*** addCylindricalCoordinatesAndBasis ***")

    points = ugrid.GetPoints()
    (farray_r,
     farray_c,
     farray_l,
     farray_eR,
     farray_eC,
     farray_eL) = computeCylindricalCoordinatesAndBasis(
        points=points,
        points_AB=points_AB,
        verbose=verbose-1)

    ugrid.GetPointData().AddArray(farray_r)
    ugrid.GetPointData().AddArray(farray_c)
    ugrid.GetPointData().AddArray(farray_l)
    ugrid.GetPointData().AddArray(farray_eR)
    ugrid.GetPointData().AddArray(farray_eC)
    ugrid.GetPointData().AddArray(farray_eL)

    cell_centers = myVTK.getCellCenters(
        mesh=ugrid,
        verbose=verbose-1)
    (farray_r,
     farray_c,
     farray_l,
     farray_eR,
     farray_eC,
     farray_eL) = computeCylindricalCoordinatesAndBasis(
        points=cell_centers,
        points_AB=points_AB,
        verbose=verbose-1)

    ugrid.GetCellData().AddArray(farray_r)
    ugrid.GetCellData().AddArray(farray_c)
    ugrid.GetCellData().AddArray(farray_l)
    ugrid.GetCellData().AddArray(farray_eR)
    ugrid.GetCellData().AddArray(farray_eC)
    ugrid.GetCellData().AddArray(farray_eL)
コード例 #7
0
def addCartesianCoordinates(ugrid, verbose=0):

    myVTK.myPrint(verbose, "*** addCartesianCoordinates ***")

    points = ugrid.GetPoints()
    (farray_xx, farray_yy,
     farray_zz) = computeCartesianCoordinates(points=points,
                                              verbose=verbose - 1)

    ugrid.GetPointData().AddArray(farray_xx)
    ugrid.GetPointData().AddArray(farray_yy)
    ugrid.GetPointData().AddArray(farray_zz)

    cell_centers = myVTK.getCellCenters(mesh=ugrid, verbose=verbose - 1)
    (farray_xx, farray_yy,
     farray_zz) = computeCartesianCoordinates(points=cell_centers,
                                              verbose=verbose - 1)

    ugrid.GetCellData().AddArray(farray_xx)
    ugrid.GetCellData().AddArray(farray_yy)
    ugrid.GetCellData().AddArray(farray_zz)
コード例 #8
0
def addRegionsToBiV(ugrid_mesh,
                    pdata_endLV,
                    pdata_endRV,
                    pdata_epi,
                    verbose=0):

    myVTK.myPrint(verbose, "*** addRegionsToBiV ***")

    points = ugrid_mesh.GetPoints()
    iarray_region = computeRegionsForBiV(points=points,
                                         pdata_endLV=pdata_endLV,
                                         pdata_endRV=pdata_endRV,
                                         pdata_epi=pdata_epi,
                                         verbose=verbose - 1)
    ugrid_mesh.GetPointData().AddArray(iarray_region)

    cell_centers = myVTK.getCellCenters(mesh=ugrid_mesh, verbose=verbose - 1)
    iarray_region = computeRegionsForBiV(points=cell_centers,
                                         pdata_endLV=pdata_endLV,
                                         pdata_endRV=pdata_endRV,
                                         pdata_epi=pdata_epi,
                                         verbose=verbose - 1)
    ugrid_mesh.GetCellData().AddArray(iarray_region)
コード例 #9
0
def mapDataSetToCellData(
        mesh_from,
        type_of_support,
        mesh_to,
        farray_names,
        type_of_mapping="PointsWithinRadius",
        radius_is_relative=True,
        radius=0.5,
        n_closest_points=3,
        threshold_dist=None,
        threshold_val_min=None,
        threshold_val_max=None,
        verbose=0):

    myVTK.myPrint(verbose, "*** mapDataSetToCellData ***")

    if (type_of_support == "point"):
        datapoints = mesh_from.GetPoints()
        dataset = mesh_from.GetPointData()
        point_locator = myVTK.getPointLocator(
            mesh_from,
            verbose=verbose-1)
    elif (type_of_support == "cell"):
        datapoints = myVTK.getCellCenters(
            mesh=mesh_from,
            verbose=verbose-1)
        dataset = mesh_from.GetCellData()
        point_locator = myVTK.getPointLocator(
            datapoints,
            verbose=verbose-1)
    else:
        assert (0)

    pdata_cell_centers_to = myVTK.getCellCenters(mesh_to)
    n_cells = mesh_to.GetNumberOfCells()

    farrays_avg = {}
    farrays_std = {}
    for farray_name in farray_names:
        assert (dataset.HasArray(farray_name)), "mesh has no array named "+farray_name+". Aborting."

        farray_type = dataset.GetArray(farray_name).GetDataTypeAsString()
        farray_n_components = dataset.GetArray(farray_name).GetNumberOfComponents()
        farrays_avg[farray_name] = myVTK.createArray(farray_name+"_avg",
            farray_n_components,
            n_cells,
            farray_type)
        farrays_std[farray_name] = myVTK.createArray(farray_name+"_std",
            farray_n_components,
            n_cells,
            farray_type)

    points_within_radius = vtk.vtkIdList()

    for k_cell in xrange(n_cells):

        if (type_of_mapping == "ClosestPoints"):
            point_locator.FindClosestNPoints(
                n_closest_points,
                pdata_cell_centers_to.GetPoint(k_cell),
                points_within_radius)
        elif (type_of_mapping == "PointsWithinRadius"):
            if (radius_is_relative):
                l = (mesh_to.GetCell(k_cell).GetLength2())**(0.5)
                actual_radius = l*radius
            else:
                actual_radius = radius
            point_locator.FindPointsWithinRadius(
                actual_radius,
                pdata_cell_centers_to.GetPoint(k_cell),
                points_within_radius)
        else:
            assert (0)

        #points_within_radius = myVTK.findPointsInCell(mesh_from.GetPoints(), mesh_to.GetCell(k_cell))

        for farray_name in farray_names:
            if (points_within_radius.GetNumberOfIds()):
                values = [numpy.array(dataset.GetArray(farray_name).GetTuple(points_within_radius.GetId(k_id))) for k_id in xrange(points_within_radius.GetNumberOfIds()) if (threshold_dist is None) or (numpy.linalg.norm(numpy.array(datapoints.GetPoint(points_within_radius.GetId(k_id)))-numpy.array(pdata_cell_centers_to.GetPoint(k_cell))) < threshold_dist)]
                #print "values = "+str(values)
                if (threshold_val_min != None):
                    values = [value for value in values if (numpy.linalg.norm(value) > threshold_val_min)]
                if (threshold_val_max != None):
                    values = [value for value in values if (numpy.linalg.norm(value) < threshold_val_max)]
                #print "values = "+str(values)
                if (len(values)):
                    avg = numpy.mean(values, 0)
                    std = numpy.std(values, 0)
                else:
                    avg = [0]*farray_n_components
                    std = [0]*farray_n_components
            else:
                avg = [0]*farray_n_components
                std = [0]*farray_n_components
            farrays_avg[farray_name].SetTuple(k_cell, avg)
            farrays_std[farray_name].SetTuple(k_cell, std)

    for farray_name in farray_names:
        mesh_to.GetCellData().AddArray(farrays_avg[farray_name])
        mesh_to.GetCellData().AddArray(farrays_std[farray_name])
コード例 #10
0
def mapDataSetToCellData(mesh_from,
                         type_of_support,
                         mesh_to,
                         farray_names,
                         type_of_mapping="PointsWithinRadius",
                         radius_is_relative=True,
                         radius=0.5,
                         n_closest_points=3,
                         threshold_dist=None,
                         threshold_val_min=None,
                         threshold_val_max=None,
                         verbose=0):

    myVTK.myPrint(verbose, "*** mapDataSetToCellData ***")

    if (type_of_support == "point"):
        datapoints = mesh_from.GetPoints()
        dataset = mesh_from.GetPointData()
        point_locator = myVTK.getPointLocator(mesh_from, verbose=verbose - 1)
    elif (type_of_support == "cell"):
        datapoints = myVTK.getCellCenters(mesh=mesh_from, verbose=verbose - 1)
        dataset = mesh_from.GetCellData()
        point_locator = myVTK.getPointLocator(datapoints, verbose=verbose - 1)
    else:
        assert (0)

    pdata_cell_centers_to = myVTK.getCellCenters(mesh_to)
    n_cells = mesh_to.GetNumberOfCells()

    farrays_avg = {}
    farrays_std = {}
    for farray_name in farray_names:
        assert (dataset.HasArray(farray_name)
                ), "mesh has no array named " + farray_name + ". Aborting."

        farray_type = dataset.GetArray(farray_name).GetDataTypeAsString()
        farray_n_components = dataset.GetArray(
            farray_name).GetNumberOfComponents()
        farrays_avg[farray_name] = myVTK.createArray(farray_name + "_avg",
                                                     farray_n_components,
                                                     n_cells, farray_type)
        farrays_std[farray_name] = myVTK.createArray(farray_name + "_std",
                                                     farray_n_components,
                                                     n_cells, farray_type)

    points_within_radius = vtk.vtkIdList()

    for k_cell in xrange(n_cells):

        if (type_of_mapping == "ClosestPoints"):
            point_locator.FindClosestNPoints(
                n_closest_points, pdata_cell_centers_to.GetPoint(k_cell),
                points_within_radius)
        elif (type_of_mapping == "PointsWithinRadius"):
            if (radius_is_relative):
                l = (mesh_to.GetCell(k_cell).GetLength2())**(0.5)
                actual_radius = l * radius
            else:
                actual_radius = radius
            point_locator.FindPointsWithinRadius(
                actual_radius, pdata_cell_centers_to.GetPoint(k_cell),
                points_within_radius)
        else:
            assert (0)

        #points_within_radius = myVTK.findPointsInCell(mesh_from.GetPoints(), mesh_to.GetCell(k_cell))

        for farray_name in farray_names:
            if (points_within_radius.GetNumberOfIds()):
                values = [
                    numpy.array(
                        dataset.GetArray(farray_name).GetTuple(
                            points_within_radius.GetId(k_id)))
                    for k_id in xrange(points_within_radius.GetNumberOfIds())
                    if (threshold_dist is None) or (numpy.linalg.norm(
                        numpy.array(
                            datapoints.GetPoint(
                                points_within_radius.GetId(k_id))) -
                        numpy.array(pdata_cell_centers_to.GetPoint(k_cell))) <
                                                    threshold_dist)
                ]
                #print "values = "+str(values)
                if (threshold_val_min != None):
                    values = [
                        value for value in values
                        if (numpy.linalg.norm(value) > threshold_val_min)
                    ]
                if (threshold_val_max != None):
                    values = [
                        value for value in values
                        if (numpy.linalg.norm(value) < threshold_val_max)
                    ]
                #print "values = "+str(values)
                if (len(values)):
                    avg = numpy.mean(values, 0)
                    std = numpy.std(values, 0)
                else:
                    avg = [0] * farray_n_components
                    std = [0] * farray_n_components
            else:
                avg = [0] * farray_n_components
                std = [0] * farray_n_components
            farrays_avg[farray_name].SetTuple(k_cell, avg)
            farrays_std[farray_name].SetTuple(k_cell, std)

    for farray_name in farray_names:
        mesh_to.GetCellData().AddArray(farrays_avg[farray_name])
        mesh_to.GetCellData().AddArray(farrays_std[farray_name])
コード例 #11
0
def addMappingToPointData(mesh_from,
                          type_of_support,
                          mesh_to,
                          farray_names,
                          radius=1.,
                          threshold_min=None,
                          threshold_max=None,
                          verbose=0):

    mypy.my_print(verbose, "*** addMappingToPointData ***")

    if (type_of_support == "point"):
        dataset = mesh_from.GetPointData()
        point_locator = myvtk.getPointLocator(mesh_from)
    elif (type_of_support == "cell"):
        dataset = mesh_from.GetPointData()
        pdata_cell_centers_fr = myvtk.getCellCenters(mesh=mesh_from,
                                                     verbose=verbose - 1)
        point_locator = myvtk.getPointLocator(pdata_cell_centers_fr)

    n_points = mesh_to.GetNumberOfPoints()

    farrays_avg = {}
    farrays_std = {}
    farrays_rat = {}
    for farray_name in farray_names:
        assert (dataset.HasArray(farray_name)
                ), "mesh has no array named " + farray_name + ". Aborting."

        farray_type = dataset.GetArray(farray_name).GetDataTypeAsString()
        farray_n_components = dataset.GetArray(
            farray_name).GetNumberOfComponents()
        farrays_avg[farray_name] = createArray(farray_name + "_avg",
                                               farray_n_components, n_points,
                                               farray_type)
        farrays_std[farray_name] = createArray(farray_name + "_std",
                                               farray_n_components, n_points,
                                               farray_type)
        farrays_rat[farray_name] = createArray(farray_name + "_rat",
                                               farray_n_components, n_points,
                                               farray_type)

    points_within_radius = vtk.vtkIdList()

    for k_point in xrange(n_points):
        #point_locator.FindClosestNPoints(
        #3,
        #mesh_to.GetPoints().GetPoint(k_point),
        #points_within_radius)
        point_locator.FindPointsWithinRadius(
            radius,
            mesh_to.GetPoints().GetPoint(k_point), points_within_radius)

        for farray_name in farray_names:
            if (points_within_radius.GetNumberOfIds() > 0):
                values = [
                    numpy.array(
                        dataset.GetArray(farray_name).GetTuple(
                            points_within_radius.GetId(k_id)))
                    for k_id in xrange(points_within_radius.GetNumberOfIds())
                ]
                #print "values = "+str(values)
                if (threshold_min != None):
                    values = [
                        value for value in values
                        if (numpy.linalg.norm(value) > threshold_min)
                    ]
                if (threshold_max != None):
                    values = [
                        value for value in values
                        if (numpy.linalg.norm(value) < threshold_max)
                    ]
                #print "values = "+str(values)
                if (len(values) > 0):
                    avg = numpy.mean(values, 0)
                    std = numpy.std(values, 0)
                    rat = std / avg
                else:
                    avg = [0] * n_components
                    std = [0] * n_components
                    rat = [0] * n_components
            else:
                avg = [0] * n_components
                std = [0] * n_components
                rat = [0] * n_components
            farrays_avg[farray_name].SetTuple(k_point, avg)
            farrays_std[farray_name].SetTuple(k_point, std)
            farrays_rat[farray_name].SetTuple(k_point, rat)

    for farray_name in farray_names:
        mesh_to.GetPointData().AddArray(farrays_avg[farray_name])
        mesh_to.GetPointData().AddArray(farrays_std[farray_name])
        mesh_to.GetPointData().AddArray(farrays_rat[farray_name])