learning3d 0.0.1__py3-none-any.whl

learning3d/models/masknet2.py

@@ -0,0 +1,264 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .pooling import Pooling
+
+
+# Mish Activation Function
+class Mish(nn.Module):
+	def __init__(self):
+		super(Mish, self).__init__()
+
+	def forward(self, x):
+		return x * torch.tanh(F.softplus(x))
+
+
+# Basic Convolution Block
+class BasicConv1D(nn.Module):
+	def __init__(self, in_channels, out_channels, kernel_size=1, stride=1, active = True):
+		super(BasicConv1D, self).__init__()
+		self.active = active
+		self.bn = nn.BatchNorm1d( out_channels)
+		if self.active == True:
+			self.activation = Mish()
+		self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, stride, bias=False)
+		#self.dropout = nn.Dropout(0.5)
+
+	def forward(self, x):
+		x = self.conv(x)
+		x = self.bn(x)
+		if self.active == True:
+			x = self.activation(x)
+		return x
+
+
+class Self_Attn(nn.Module):
+	""" Self attention Layer"""
+	def __init__(self, in_dim, out_dim):
+		super(Self_Attn,self).__init__()
+
+		self.in_dim = in_dim
+		self.out_dim = out_dim
+	
+		# Query Convolution
+		self.query_conv =BasicConv1D(in_dim, out_dim)  
+	
+		self.beta = nn.Parameter(torch.zeros(1))
+
+		self.softmax  = nn.Softmax(dim=-1) #
+
+	def forward(self,x):
+		"""
+			inputs :
+				x : input feature maps( B X C X N)  32, 1024, 64
+			returns :
+				out : self attention value + input feature 
+				attention: B X N X N (N is Width*Height)
+		"""
+
+		proj_query  = self.query_conv(x).permute(0,2,1)      # B, in_dim, N   ---> B, in_dim // 8, N   ---->  B, N, in_dim // 8
+		proj_key =   proj_query.permute(0,2,1) #B, in_dim, N   ---> B, in_dim // 8, N
+		
+		energy =  torch.bmm(proj_query,proj_key) # transpose check    B, N, N
+
+		attention = self.softmax(energy) # B , N,  N  
+
+		out_x = torch.bmm(proj_key, attention.permute(0,2,1) )   #B, out_dim, N
+	
+		out =  self.beta * out_x + proj_key 
+		
+		return out
+
+class PointNet(torch.nn.Module):
+	def __init__(self, emb_dims=224, input_shape="bnc", use_bn=False, global_feat=True):
+		# emb_dims:			Embedding Dimensions for PointNet.
+		# input_shape:		Shape of Input Point Cloud (b: batch, n: no of points, c: channels)
+		super(PointNet, self).__init__()
+		if input_shape not in ["bcn", "bnc"]:
+			raise ValueError("Allowed shapes are 'bcn' (batch * channels * num_in_points), 'bnc' ")
+		self.input_shape = input_shape
+		self.emb_dims = emb_dims
+		self.use_bn = use_bn
+		self.global_feat = global_feat
+		if not self.global_feat: self.pooling = Pooling('max')
+
+		self.conv1 = Self_Attn(3, 32)
+		self.conv2 = Self_Attn(32, 64)
+		self.conv3 = Self_Attn(64, 64)
+		self.conv4 = Self_Attn(64, 128)
+		self.conv5 = Self_Attn(128, self.emb_dims)
+
+
+	def forward(self, input_data):
+		# input_data: 		Point Cloud having shape input_shape.
+		# output:			PointNet features (Batch x emb_dims)
+
+		if self.input_shape == "bnc":
+			num_points = input_data.shape[1]
+			input_data = input_data.permute(0, 2, 1)
+		else:
+			num_points = input_data.shape[2]
+		if input_data.shape[1] != 3:
+			raise RuntimeError("shape of x must be of [Batch x 3 x NumInPoints]")
+
+		output = input_data
+		
+		x1 = self.conv1(output)  #32
+		x2 = self.conv2(x1)      #64
+		x3 = self.conv3(x2)   #64
+		x4 = self.conv4(x3+x2) #128
+		x5 = self.conv5(x4)
+
+		output  = torch.cat([ x1, x2,  x3, x4, x5], dim=1)  #256, x4 x0,
+		point_feature = output
+
+		if self.global_feat:
+			return output
+		else:
+			output = self.pooling(output)
+			output = output.view(-1, self.emb_dims, 1).repeat(1, 1, num_points)
+			return torch.cat([output, point_feature], 1)
+
+
+# self attention mechanism
+class self_attention_fc(nn.Module):
+	""" Self attention Layer""" 
+	def __init__(self,in_dim, out_dim):     #1024
+		super(self_attention_fc,self).__init__()
+		
+		self.in_dim = in_dim
+		self.out_dim = out_dim
+
+		self.query_conv = BasicConv1D(in_dim, out_dim)
+
+		self.beta = nn.Parameter(torch.zeros(1))
+		self.softmax  = nn.Softmax(dim=-1) #
+
+	def forward(self,x, y):   #B, 1024 , 1
+		"""
+			inputs :
+				x : input feature maps( B X C,1 )
+			returns :
+				out : self attention value + input feature 
+				attention: B X N X N (N is Width*Height)
+		"""
+		proj_query_x  = self.query_conv(x)                      #[B, in_dim, 1]----->[B, out_dim1, 1]
+
+		proj_key_y =   self.query_conv(y).permute(0,2,1)        #[B, 1, out_dim1]
+		
+		energy_xy =  torch.bmm(proj_query_x, proj_key_y)        #  xi Attention scores for all points in y [B, 64, 64]   
+
+		attention_xy = self.softmax(energy_xy)
+		attention_yx = self.softmax(energy_xy.permute(0,2,1))
+
+		proj_value_x = proj_query_x                             # self.value_conv_x(x) # [B, out_dim, 64]
+		proj_value_y = proj_key_y.permute(0,2,1)                # self.value_conv_x(y) # [B, out_dim, 64]
+
+		out_x = torch.bmm(attention_xy, proj_value_x)           # [B, out_dim]
+		out_x =  self.beta* out_x +  proj_value_x               # self.kama* 
+
+		out_y = torch.bmm(attention_yx, proj_value_y )          # [B, out_dim]
+		out_y =  self.beta*out_y +   proj_value_y               # self.kama *
+
+		return out_x, out_y
+
+
+
+class PointNetMask(nn.Module):
+	def __init__(self, template_feature_size=1024, source_feature_size=1024, feature_model=PointNet()):
+		super().__init__()
+		self.feature_model = feature_model
+		self.pooling_max = Pooling(pool_type='max')
+		self.pooling_avg = Pooling(pool_type='avg')
+
+		input_size = template_feature_size + source_feature_size
+
+		self.global_feat_1 = self_attention_fc(1024, 512)
+		self.global_feat_2 = self_attention_fc(512, 256)
+		self.global_feat_3 = self_attention_fc(256, 512)
+
+		self.h3 = nn.Sequential(BasicConv1D(1024, 512),
+								BasicConv1D(512,  256),
+								BasicConv1D(256,  128),
+								nn.Conv1d(128,  1, 1), nn.Sigmoid())
+
+
+	def find_mask(self, source_features, template_features):
+		global_source_features_max = self.pooling_max(source_features)
+		global_template_features_max = self.pooling_max(template_features)
+		global_source_features_avg = self.pooling_avg(source_features)
+		global_template_features_avg = self.pooling_avg(template_features)
+		global_source_features = torch.cat([global_source_features_max, global_source_features_avg], dim=1)
+		global_template_features = torch.cat([global_template_features_max, global_template_features_avg], dim=1)
+
+		shared_feat_1,shared_feat_2  = self.global_feat_1(global_source_features.unsqueeze(2), global_template_features.unsqueeze(2))
+		shared_feat_1,shared_feat_2  = self.global_feat_2(shared_feat_1, shared_feat_2) 
+		shared_feat_1,shared_feat_2  = self.global_feat_3(shared_feat_1, shared_feat_2) 
+
+		batch_size, _ , num_points = source_features.size()
+		global_source_features = shared_feat_1
+		global_source_features = global_source_features.repeat(1,1,num_points)
+		x = torch.cat([template_features, global_source_features], dim=1)
+		x = self.h3(x)
+
+		batch_size, _ , num_points = template_features.size()
+		global_template_features = shared_feat_2
+		global_template_features = global_template_features.repeat(1,1,num_points)
+		y = torch.cat([source_features, global_template_features], dim=1)
+		y = self.h3(y)
+
+		return x.view(batch_size, -1), y.view(batch_size, -1)
+
+	def forward(self, template, source):
+		source_features = self.feature_model(source)				# [B x C x N]
+		template_features = self.feature_model(template)			# [B x C x N]
+
+		template_mask, source_mask = self.find_mask(source_features, template_features)
+		return template_mask, source_mask
+
+class MaskNet2(nn.Module):
+	def __init__(self, feature_model=PointNet(use_bn=True), is_training=True):
+		super().__init__()
+		self.maskNet = PointNetMask(feature_model=feature_model)
+		self.is_training = is_training
+
+	@staticmethod
+	def index_points(points, idx):
+		"""
+		Input:
+			points: input points data, [B, N, C]
+			idx: sample index data, [B, S]
+		Return:
+			new_points:, indexed points data, [B, S, C]
+		"""
+		device = points.device
+		B = points.shape[0]
+		view_shape = list(idx.shape)
+		view_shape[1:] = [1] * (len(view_shape) - 1)
+		repeat_shape = list(idx.shape)
+		repeat_shape[0] = 1
+		batch_indices = torch.arange(B, dtype=torch.long).to(device).view(view_shape).repeat(repeat_shape)
+		new_points = points[batch_indices, idx, :]
+
+		return new_points
+
+	def forward(self, template, source, point_selection='threshold', mask_threshold = 0.5):
+		template_mask, source_mask = self.maskNet(template, source)   #B, N
+		if not torch.cuda.is_available():
+			device = 'cpu'
+		device = torch.device(device)
+		
+		source_binary_mask = torch.where(source_mask > mask_threshold, torch.ones(source_mask.size()).to(device), torch.zeros(source_mask.size()).to(device))  
+		template_binary_mask = torch.where(template_mask > mask_threshold, torch.ones(template_mask.size()).to(device), torch.zeros(template_mask.size()).to(device))
+
+		masked_template = template[:, torch.tensor(template_binary_mask, dtype = torch.bool).squeeze(0), 0:3]
+		masked_source = source[:, torch.tensor(source_binary_mask, dtype = torch.bool).squeeze(0), 0:3]
+
+		return masked_template, masked_source, template_mask, source_mask
+
+
+if __name__ == '__main__':
+	template, source = torch.rand(10,1024,3), torch.rand(10,1024,3)
+	net = MaskNet2()
+	result = net(template, source)
+	import ipdb; ipdb.set_trace()

learning3d/models/pcn.py

@@ -0,0 +1,164 @@
+# author: Vinit Sarode (vinitsarode5@gmail.com) 03/23/2020
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .pooling import Pooling
+
+class PCN(torch.nn.Module):
+	def __init__(self, emb_dims=1024, input_shape="bnc", num_coarse=1024, grid_size=4, detailed_output=False):
+		# emb_dims:			Embedding Dimensions for PCN.
+		# input_shape:		Shape of Input Point Cloud (b: batch, n: no of points, c: channels)
+		super(PCN, self).__init__()
+		if input_shape not in ["bcn", "bnc"]:
+			raise ValueError("Allowed shapes are 'bcn' (batch * channels * num_in_points), 'bnc' ")
+		self.input_shape = input_shape
+		self.emb_dims = emb_dims
+		self.num_coarse = num_coarse
+		self.detailed_output = detailed_output
+		self.grid_size = grid_size
+		self.num_fine = self.grid_size ** 2 * self.num_coarse
+		self.pooling = Pooling('max')
+
+		self.encoder()
+		self.decoder_layers = self.decoder()
+		if detailed_output: self.folding_layers = self.folding()
+
+	def encoder_1(self):
+		self.conv1 = torch.nn.Conv1d(3, 128, 1)
+		self.conv2 = torch.nn.Conv1d(128, 256, 1)
+		self.relu = torch.nn.ReLU()
+
+		# self.bn1 = torch.nn.BatchNorm1d(128)
+		# self.bn2 = torch.nn.BatchNorm1d(256)
+
+		layers = [self.conv1, self.relu,
+				  self.conv2]
+		return layers
+
+	def encoder_2(self):
+		self.conv3 = torch.nn.Conv1d(2*256, 512, 1)
+		self.conv4 = torch.nn.Conv1d(512, self.emb_dims, 1)
+
+		# self.bn3 = torch.nn.BatchNorm1d(512)
+		# self.bn4 = torch.nn.BatchNorm1d(self.emb_dims)
+		self.relu = torch.nn.ReLU()
+
+		layers = [self.conv3, self.relu,
+				  self.conv4]
+		return layers
+
+	def encoder(self):
+		self.encoder_layers1 = self.encoder_1()
+		self.encoder_layers2 = self.encoder_2()
+
+	def decoder(self):
+		self.linear1 = torch.nn.Linear(self.emb_dims, 1024)
+		self.linear2 = torch.nn.Linear(1024, 1024)
+		self.linear3 = torch.nn.Linear(1024, self.num_coarse*3)
+
+		# self.bn1 = torch.nn.BatchNorm1d(1024)
+		# self.bn2 = torch.nn.BatchNorm1d(1024)
+		# self.bn3 = torch.nn.BatchNorm1d(self.num_coarse*3)
+		self.relu = torch.nn.ReLU()
+
+		layers = [self.linear1, self.relu,
+				  self.linear2, self.relu,
+				  self.linear3]
+		return layers
+
+	def folding(self):
+		self.conv5 = torch.nn.Conv1d(1029, 512, 1)
+		self.conv6 = torch.nn.Conv1d(512, 512, 1)
+		self.conv7 = torch.nn.Conv1d(512, 3, 1)
+
+		# self.bn5 = torch.nn.BatchNorm1d(512)
+		# self.bn6 = torch.nn.BatchNorm1d(512)
+		self.relu = torch.nn.ReLU()
+
+		layers = [self.conv5, self.relu,
+				  self.conv6, self.relu,
+				  self.conv7]
+		return layers
+
+	def fine_decoder(self):
+		# Fine Output
+		linspace = torch.linspace(-0.05, 0.05, steps=self.grid_size)
+		grid = torch.meshgrid(linspace, linspace)
+		grid = torch.reshape(torch.stack(grid, dim=2), (-1,2))								# 16x2
+		grid = torch.unsqueeze(grid, dim=0)													# 1x16x2
+		grid_feature = grid.repeat([self.coarse_output.shape[0], self.num_coarse, 1])		# Bx16384x2
+
+		point_feature = torch.unsqueeze(self.coarse_output, dim=2)							# Bx1024x1x3
+		point_feature = point_feature.repeat([1, 1, self.grid_size ** 2, 1])				# Bx1024x16x3
+		point_feature = torch.reshape(point_feature, (-1, self.num_fine, 3))				# Bx16384x3
+
+		global_feature = torch.unsqueeze(self.global_feature_v, dim=1)						# Bx1x1024
+		global_feature = global_feature.repeat([1, self.num_fine, 1])						# Bx16384x1024
+
+		feature = torch.cat([grid_feature, point_feature, global_feature], dim=2)			# Bx16384x1029
+
+		center = torch.unsqueeze(self.coarse_output, dim=2)									# Bx1024x1x3
+		center = center.repeat([1, 1, self.grid_size ** 2, 1])								# Bx1024x16x3
+		center = torch.reshape(center, [-1, self.num_fine, 3])								# Bx16384x3
+
+		output = feature.permute(0, 2, 1)
+		for idx, layer in enumerate(self.folding_layers):
+			output = layer(output)
+		fine_output = output.permute(0, 2, 1) + center
+		return fine_output
+
+	def encode(self, input_data):
+		output = input_data
+		for idx, layer in enumerate(self.encoder_layers1):
+			output = layer(output)
+
+		global_feature_g = self.pooling(output)
+
+		global_feature_g = global_feature_g.unsqueeze(2)
+		global_feature_g = global_feature_g.repeat(1,1,self.num_points)
+		output = torch.cat([output, global_feature_g], dim=1)
+
+		for idx, layer in enumerate(self.encoder_layers2):
+			output = layer(output)
+
+		self.global_feature_v = self.pooling(output)
+
+	def decode(self):
+		output = self.global_feature_v
+		for idx, layer in enumerate(self.decoder_layers):
+			output = layer(output)		
+		self.coarse_output = output.view(self.global_feature_v.shape[0], self.num_coarse, 3)
+
+	def forward(self, input_data):
+		# input_data: 		Point Cloud having shape input_shape.
+		# output:			PointNet features (Batch x emb_dims)
+		if self.input_shape == "bnc":
+			self.num_points = input_data.shape[1]
+			input_data = input_data.permute(0, 2, 1)
+		else:
+			self.num_points = input_data.shape[2]
+		if input_data.shape[1] != 3:
+			raise RuntimeError("shape of x must be of [Batch x 3 x NumInPoints]")
+
+		self.encode(input_data)
+		self.decode()
+
+		result = {'coarse_output': self.coarse_output}
+
+		if self.detailed_output: 
+			fine_output = self.fine_decoder()
+			result['fine_output'] = fine_output
+
+		return result
+
+		
+if __name__ == '__main__':
+	# Test the code.
+	x = torch.rand((10,1024,3))
+
+	pcn = PCN()
+	y = pcn(x)
+	print("Network Architecture: ")
+	print(pn)
+	print("Input Shape of PCN: ", x.shape, "\nOutput Shape of PCN: ", y['coarse_output'].shape)

learning3d/models/pcrnet.py

@@ -0,0 +1,74 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .pointnet import PointNet
+from .pooling import Pooling
+from .. ops.transform_functions import PCRNetTransform as transform
+
+
+class iPCRNet(nn.Module):
+	def __init__(self, feature_model=PointNet(), droput=0.0, pooling='max'):
+		super().__init__()
+		self.feature_model = feature_model
+		self.pooling = Pooling(pooling)
+
+		self.linear = [nn.Linear(self.feature_model.emb_dims * 2, 1024), nn.ReLU(),
+				   	   nn.Linear(1024, 1024), nn.ReLU(),
+				   	   nn.Linear(1024, 512), nn.ReLU(),
+				   	   nn.Linear(512, 512), nn.ReLU(),
+				   	   nn.Linear(512, 256), nn.ReLU()]
+
+		if droput>0.0:
+			self.linear.append(nn.Dropout(droput))
+		self.linear.append(nn.Linear(256,7))
+
+		self.linear = nn.Sequential(*self.linear)
+
+	# Single Pass Alignment Module (SPAM)
+	def spam(self, template_features, source, est_R, est_t):
+		batch_size = source.size(0)
+
+		self.source_features = self.pooling(self.feature_model(source))
+		y = torch.cat([template_features, self.source_features], dim=1)
+		pose_7d = self.linear(y)
+		pose_7d = transform.create_pose_7d(pose_7d)
+
+		# Find current rotation and translation.
+		identity = torch.eye(3).to(source).view(1,3,3).expand(batch_size, 3, 3).contiguous()
+		est_R_temp = transform.quaternion_rotate(identity, pose_7d).permute(0, 2, 1)
+		est_t_temp = transform.get_translation(pose_7d).view(-1, 1, 3)
+
+		# update translation matrix.
+		est_t = torch.bmm(est_R_temp, est_t.permute(0, 2, 1)).permute(0, 2, 1) + est_t_temp
+		# update rotation matrix.
+		est_R = torch.bmm(est_R_temp, est_R)
+		
+		source = transform.quaternion_transform(source, pose_7d)      # Ps' = est_R*Ps + est_t
+		return est_R, est_t, source
+
+	def forward(self, template, source, max_iteration=8):
+		est_R = torch.eye(3).to(template).view(1, 3, 3).expand(template.size(0), 3, 3).contiguous()         # (Bx3x3)
+		est_t = torch.zeros(1,3).to(template).view(1, 1, 3).expand(template.size(0), 1, 3).contiguous()     # (Bx1x3)
+		template_features = self.pooling(self.feature_model(template))
+
+		if max_iteration == 1:
+			est_R, est_t, source = self.spam(template_features, source, est_R, est_t)
+		else:
+			for i in range(max_iteration):
+				est_R, est_t, source = self.spam(template_features, source, est_R, est_t)
+
+		result = {'est_R': est_R,				# source -> template
+				  'est_t': est_t,				# source -> template
+				  'est_T': transform.convert2transformation(est_R, est_t),			# source -> template
+				  'r': template_features - self.source_features,
+				  'transformed_source': source}
+		return result
+
+
+if __name__ == '__main__':
+	template, source = torch.rand(10,1024,3), torch.rand(10,1024,3)
+	pn = PointNet()
+	
+	net = iPCRNet(pn)
+	result = net(template, source)
+	import ipdb; ipdb.set_trace()

learning3d/models/pointconv.py

@@ -0,0 +1,108 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .. utils import PointConvDensitySetAbstraction
+
+class PointConvDensityClsSsg(torch.nn.Module):
+	def __init__(self, emb_dims=1024, input_shape="bnc", input_channel_dim=3, classifier=False, num_classes=40, pretrained=None):
+		super(PointConvDensityClsSsg, self).__init__()
+		if input_shape not in ["bnc", "bcn"]:
+			raise ValueError("Allowed shapes are 'bcn' (batch * channels * num_in_points), 'bnc' ")
+		self.input_shape = input_shape
+		self.emb_dims = emb_dims
+		self.classifier = classifier
+		self.input_channel_dim = input_channel_dim
+		self.create_structure()
+		if self.classifier: self.create_classifier(num_classes)
+
+	def create_structure(self):
+		# Arguments to define PointConv network using PointConvDensitySetAbstraction class.
+			# npoint:			number of points sampled from input.
+			# nsample:			number of neighbours chosen for each point in sampled point cloud.
+			# in_channel:		number of channels in input.
+			# mlp:				sizes of multi-layer perceptrons.
+			# bandwidth:		used to compute gaussian density.
+			# group_all:		group all points from input to a single point if set to True.
+		self.sa1 = PointConvDensitySetAbstraction(npoint=512, nsample=32, in_channel=self.input_channel_dim, 
+													mlp=[64, 64, 128], bandwidth = 0.1, group_all=False)
+		self.sa2 = PointConvDensitySetAbstraction(npoint=128, nsample=64, in_channel=128 + 3, 
+													mlp=[128, 128, 256], bandwidth = 0.2, group_all=False)
+		self.sa3 = PointConvDensitySetAbstraction(npoint=1, nsample=None, in_channel=256 + 3, 
+													mlp=[256, 512, self.emb_dims], bandwidth = 0.4, group_all=True)
+
+	def create_classifier(self, num_classes):
+		# These are simple fully-connected layers with batch-norm and dropouts.
+		# This architecture is given by PointConv paper. Hence, I used it here as a default version.
+		# This can be easily modified by overwriting this function or by using classifier.py class.
+		self.fc1 = nn.Linear(self.emb_dims, 512)
+		self.bn1 = nn.BatchNorm1d(512)
+		self.drop1 = nn.Dropout(0.7)
+		self.fc2 = nn.Linear(512, 256)
+		self.bn2 = nn.BatchNorm1d(256)
+		self.drop2 = nn.Dropout(0.7)
+		self.fc3 = nn.Linear(256, num_classes)		
+
+	def forward(self, input_data):
+		if self.input_shape == "bnc":
+			input_data = input_data.permute(0, 2, 1)
+		batch_size = input_data.shape[0]
+
+		# Convert point clouds to latent features using PointConv network.
+		l1_points, l1_features = self.sa1(input_data[:, :3, :], input_data[:, 3:, :])
+		l2_points, l2_features = self.sa2(l1_points, l1_features)
+		l3_points, l3_features = self.sa3(l2_points, l2_features)
+		features = l3_features.view(batch_size, self.emb_dims)
+
+		if self.classifier:
+			# Use these features to classify the input point cloud.
+			features = self.drop1(F.relu(self.bn1(self.fc1(features))))
+			features = self.drop2(F.relu(self.bn2(self.fc2(features))))
+			features = self.fc3(features)
+			output = F.log_softmax(features, -1)
+		else:
+			# Return the PointConv features for the use of other higher level tasks.
+			output = features
+
+		return output
+
+def create_pointconv(classifier=False, pretrained=None):
+	if classifier and pretrained is not None:
+		class Network(torch.nn.Module):
+			def __init__(self, emb_dims=1024, input_shape="bnc", input_channel_dim=3, classifier=False, num_classes=40, pretrained=None):
+				# Arguments:
+					# emb_dims:				Size of embeddings.
+					# input_shape:			Shape of input point cloud.
+					# input_channel_dim:	Number of channels in point cloud. [eg. Nx3 (only points) or Nx6 (points + normals)]
+					# classifier:			Do you want to use default classifier layers or just the embedding layers.
+					# num_classes:			If you use classifier then decide the number of classes in your dataset.
+					# use_pretrained:		Use pretrained classification network.
+				super(PointConv, self).__init__()
+				self.pointconv = PointConvDensityClsSsg(emb_dims, input_shape, input_channel_dim, classifier, num_classes)
+				# super().__init__(emb_dims, input_shape, input_channel_dim, classifier, num_classes)
+				if classifier and pretrained is not None:
+					self.use_pretrained(pretrained)
+
+			def use_pretrained(self, pretrained):
+				checkpoint = torch.load(pretrained, map_location='cpu')
+				self.pointconv.load_state_dict(checkpoint['model_state_dict'])
+
+			def forward(self, input_data):
+				return self.pointconv(input_data)
+		return Network
+	else:
+		class Network(PointConvDensityClsSsg):
+			def __init__(self, emb_dims=1024, input_shape="bnc", input_channel_dim=3, classifier=False, num_classes=40, pretrained=None):
+				super().__init__(emb_dims=emb_dims, input_shape=input_shape, input_channel_dim=input_channel_dim, classifier=classifier, num_classes=num_classes, pretrained=pretrained)
+		return Network
+
+
+if __name__ == '__main__':
+	# Test the code.
+	x = torch.rand((2,1024,3))
+
+	PointConv = create_pointconv(classifier=False, pretrained='checkpoint.pth')
+	pc = PointConv(input_channel_dim=3, classifier=False, pretrained='checkpoint.pth')
+	y = pc(x)
+	print("Network Architecture: ")
+	print(pc)
+	print("Input Shape of PointNet: ", x.shape, "\nOutput Shape of PointNet: ", y.shape)