Electronic device and image editing method

Abstract

An electronic device, according to one embodiment of the present disclosure, comprises: a display; a memory for storing instructions; and a processor. The instructions, when executed by the processor, may instruct the electronic device to: display, through the display, an image including at least one object; generate skeleton information at least partially on the basis of determining that the at least one object corresponds to a deformable object; display, through the display, a graphical object, corresponding to the skeleton information, on the at least one object in the image; at least partially on the basis of a first user input, display, through the display, the graphical object which has been modified so that at least a portion of the graphical object is changed; generate a prompt on the basis of the modified graphical object and at least a portion of the image; and generate an artificial intelligence (AI) image based on the prompt by using an AI model.

Description

Electronic Devices and Image Editing Methods

[0001] The present disclosure relates to an electronic device and an image editing method.

[0002] A variety of electronic devices, including smartphones, tablet PCs, portable multimedia players (PMPs), personal digital assistants (PDAs), laptop personal computers (PCs), and wearable devices like wristwatches and head-mounted displays (HMDs), include cameras and can capture images. There is a growing demand among users for easy editing of captured images.

[0003] An electronic device according to one embodiment of the present disclosure may include a display.

[0004] An electronic device according to one embodiment of the present disclosure may include a memory that stores instructions.

[0005] An electronic device according to one embodiment of the present disclosure may include a processor.

[0006] The instructions according to one embodiment of the present disclosure, when executed by the processor, may cause the electronic device to display an image including at least one object through the display.

[0007] The instructions according to one embodiment of the present disclosure, when executed by the processor, may cause the electronic device to generate skeleton information based at least in part on a determination that the at least one object corresponds to a deformable object.

[0008] The instructions according to one embodiment of the present disclosure, when executed by the processor, may cause the electronic device to display a graphical object corresponding to the skeleton information on the at least one object on the image through the display.

[0009] The instructions according to one embodiment of the present disclosure, when executed by the processor, may cause the electronic device to display a modified graphical object through the display such that at least a portion of the graphical object is changed, at least in part based on a first user input.

[0010] The instructions according to one embodiment of the present disclosure, when executed by the processor, may cause the electronic device to generate a prompt based on at least a portion of the modified graphical object and image.

[0011] The instructions according to one embodiment of the present disclosure, when executed by the processor, may cause the electronic device to generate an AI (artificial intelligence) image based on the prompt using an artificial intelligence model.

[0012] A method for editing an image of an electronic device according to one embodiment of the present disclosure may include an operation of displaying an image including at least one object through a display.

[0013] An image editing method of an electronic device according to one embodiment of the present disclosure may include an operation of generating skeleton information based at least in part on a determination that at least one object corresponds to a deformable object.

[0014] An image editing method of an electronic device according to one embodiment of the present disclosure may include an operation of displaying a graphical object corresponding to skeleton information on at least one object on the image through the display.

[0015] A method for editing an image of an electronic device according to one embodiment of the present disclosure may include displaying a modified graphic object through the display such that at least a portion of the graphic object is changed, based at least in part on a first user input.

[0016] A method for editing an image of an electronic device according to one embodiment of the present disclosure may include an operation of generating a prompt based on at least a portion of the modified graphic object and image.

[0017] An image editing method of an electronic device according to one embodiment of the present disclosure may include an operation of generating an AI (artificial intelligence) image based on the prompt using an artificial intelligence model.

[0018] In connection with the description of the drawings, the same or similar reference numerals may be used for the same or similar components.

[0019] FIG. 1 is a block diagram of an exemplary electronic device capable of performing the operations described within the present disclosure.

[0020] FIG. 2 is a block diagram illustrating an integrated intelligence system according to one embodiment.

[0021] FIG. 3 is a block diagram illustrating an electronic device according to one embodiment of the present disclosure.

[0022] FIG. 4 is a flowchart illustrating an image editing method of an electronic device according to one embodiment of the present disclosure.

[0023] FIG. 5 is a diagram illustrating an image editing method of an electronic device according to one embodiment of the present disclosure.

[0024] FIG. 6 is a diagram illustrating an image editing method of an electronic device according to one embodiment of the present disclosure.

[0025] FIG. 7A and FIG. 7B are diagrams illustrating an image editing method of an electronic device according to one embodiment of the present disclosure.

[0026] FIG. 8 is a drawing illustrating an image editing method of an electronic device according to one embodiment of the present disclosure.

[0027] FIG. 9 is a diagram illustrating an image editing method of an electronic device according to one embodiment of the present disclosure.

[0028] In the image, there was difficulty in freely and diversely transforming the shape of the object.

[0029] The electronic device and image editing method of the present disclosure can obtain an image in which the position of an object is naturally edited by moving the object based on depth information on the image.

[0030] An electronic device and an image editing method of an electronic device according to one embodiment of the present disclosure automatically generate skeleton information corresponding to an object or generates it according to user input, so that a user can freely and variously transform the shape of an object on an image when performing image editing.

[0031] FIG. 1 is a block diagram of an exemplary electronic device (100) capable of performing the operations described within the present disclosure.

[0032] Referring to FIG. 1, the electronic device (100) may be one of various forms of electronic devices, such as a notebook (190), smartphones (191) having various form factors (e.g., a bar-type smartphone (191-1), a foldable-type smartphone (191-2), or a sliderable (or rollable) type smartphone (191-3)), a tablet (192), a cellular phone (not shown), and other similar computing devices (not shown). The components, their relationships, and their functions illustrated in FIG. 1 are exemplary only and do not limit the implementations described or claimed within the present disclosure. The electronic device (100) may be referred to as a mobile device, a user device, a multi-function device, a portable device, or a server.

[0033] The electronic device (100) may include components including at least one processor (110) (hereinafter referred to as processor (110)), at least one memory (120) (hereinafter referred to as memory (120)), at least one display (140) (hereinafter referred to as display (140)), at least one image sensor (150) (hereinafter referred to as image sensor (150)), at least one communication circuit (160) (hereinafter referred to as communication circuit (160)), and / or at least one sensor (170) (hereinafter referred to as sensor (170)). The above components are merely exemplary. For example, the electronic device (100) may include other components (e.g., power management integrated circuitry (PMIC), audio processing circuitry, an antenna, a rechargeable battery, or an input / output interface). For example, some components may be omitted from the electronic device (100). For example, some components may be integrated into one component.

[0034] The processor (110) may be implemented as one or more IC (integrated circuit (or circuitry)) chips and may perform various data processing. The processor (110) may include at least one electrical circuit and may individually or collectively perform distributed processing of instructions (or programs, data, etc.) stored in the memory (120). The processor (110) may include a processor assembly including one or more processing circuits. The processor (110) may include any processing circuit operative to control the performance and operations of one or more components (e.g., the memory (120), the display (140), the image sensor (150), the communication circuit (160), and / or the sensor (170)) of the electronic device (100). For example, the processor (110) (e.g., the application processor (AP)) may be implemented as a system on chip (SoC) (e.g., a single chip or a chipset). For example, the processor (110) may be implemented with multiple cores (or at least one core circuit), multiple chips, or multiple chipsets. For example, the processor (110) may include one or more processing circuits. For example, the processor (110) may include one or more processing circuits configured to individually and / or collectively perform various functions of the present disclosure. As a non-limiting example, at least a portion of the processor (110) may be included in a first chip of the electronic device (100), and at least another portion of the processor (110) may be included in a second chip of the electronic device (100) that is different from the first chip of the electronic device (100).

[0035] For example, the processor (110) may include a central processing unit (CPU) (111), a graphics processing unit (GPU) (112), a neural processing unit (NPU) (113), an image signal processor (ISP) (114), a display controller (115), a memory controller (116), a storage controller (117), a communication processor (CP) (118), and / or a sensor interface (119). These components of the processor (110) are merely exemplary. For example, the processor (110) may further include other components. For example, some components of the processor (110) may be omitted from the processor (110). For example, some components of the processor (110) may be included as separate components of the electronic device (100) outside the processor (110). For example, some components of the processor (110) (e.g., memory controller (116)) may be included within other components (e.g., at least a portion of memory (120), an interface (e.g., available for connection to at least one component of the electronic device (100)), a display (140) and / or an image sensor (150)).

[0036] The processor (110) may cause other components of the electronic device (100) to perform various operations by executing instructions stored in the memory (120). The CPU (111) (or central processing circuit) may be configured to control components of the processor (110) based on the execution of instructions stored in the memory (120) (e.g., volatile memory (121) and / or non-volatile memory (122)). The GPU (112) (or graphics processing circuit) may be configured to execute parallel operations (e.g., rendering). The NPU (113) (or neural processing circuit, or artificial intelligence (AI) chip) may be configured to execute operations for an artificial intelligence model (e.g., convolution computation). The ISP (114) (or image signal processing circuit) may be configured to process a raw image acquired through the image sensor (150) into a format suitable for a component within the electronic device (100) or a component of the processor (110). The display controller (115) (or display control circuit, or display processing unit (DPU)) may be configured to process an image acquired from the CPU (111), the GPU (112), the ISP (114), or the memory (120) (e.g., the volatile memory (121)) into a format suitable for the display (140). The memory controller (116) (or memory control circuit) may be configured to control reading data from the volatile memory (121) and writing data to the volatile memory (121). The storage controller (117) (or storage control circuit) may be configured to control reading data from the nonvolatile memory (122) and writing data to the nonvolatile memory (122).The CP (118) (communication processing circuit) may be configured to process data acquired from a component of the processor (110) into a format suitable for transmission to another electronic device via the communication circuit (160), or to process data acquired from another electronic device via the communication circuit (160) into a format suitable for processing by the component of the processor (110). For example, the communication circuit (160) may include one or more communication circuits. The sensor interface (119) (or sensing data processing circuit, sensor hub) may be configured to process data about the state of the electronic device (100) and / or the state of the surroundings of the electronic device (100), acquired via the sensor (170), into a format suitable for the component of the processor (110).

[0037] The memory (120) may include one or more storage media (or one or more storage devices). For example, the memory (120) may include a memory assembly including one or more storage media. For example, the one or more storage media may include permanent memory (e.g., non-volatile memory (122)) such as a hard drive, flash memory, read-only memory (ROM), semi-permanent memory (e.g., volatile memory (121)) such as random access memory (RAM), any other suitable type of storage (or storage assembly), or any combination thereof. The memory (120) may include cache memory, which is one or more different types of memory used to temporarily store data for a function or feature of the electronic device (100). As a non-limiting example, the cache memory may be included within the processor (110). The memory (120) may be fixedly embedded within the electronic device (100) or incorporated into one or more suitable types of components (e.g., a subscriber identity module (SIM) card and / or a secure digital (SD) card) that may be repeatedly inserted into and removed from the electronic device (100).

[0038] For example, the memory (120) may store one or more software applications, such as an operating system (or system) software application, a firmware software application, a driver software application, a plug-in (e.g., add-in, add-on, and / or applet) software application, and / or any other suitable software applications. For example, the one or more software applications may include instructions executable by the processor (110). For example, the memory (120) may store instructions callable by an application programming interface (API). For example, the memory (120) may store instructions within a library.

[0039] FIG. 2 is a block diagram illustrating an integrated intelligence system according to one embodiment.

[0040] Referring to FIG. 2, the integrated intelligence system may include an electronic device (203) (e.g., a user terminal) and an intelligent server (202). The electronic device (203) and the intelligent server (202) may be connected to each other via a network to transmit and receive data. According to one embodiment, the integrated intelligence system may be composed of a single device (e.g., the electronic device (203) or the intelligent server (202)). According to one embodiment, the intelligent server (202) may include the entire configuration or at least a portion of the configuration of the intelligent server (200) illustrated in FIG. 2. For example, the intelligent server (202) may execute one or more programs including the natural language platform (220) of the intelligent server (200) illustrated in FIG. 2 and / or store a capsule database (230). The configuration of the intelligent server (202) is not limited to that illustrated in FIG. 2. For example, at least some components of the natural language platform (220) (e.g., automatic speech recognition module (221), natural language understanding module (223), planner module (225), natural language generation module (227), and / or text-to-speech module (229)) may be omitted from the intelligent server (202). For example, the intelligent server (202) may further include some components of the intelligent server (200) of FIG. 2 (e.g., front end (210), execution engine (240), and / or end user interface (250)).

[0041] The electronic device (203) can execute one or more programs including a natural language platform (250) and / or store a capsule database (260). For example, the electronic device (203) can further execute one or more programs including a natural language platform (250) and / or store a capsule database (260) while including components of the electronic device (201) of FIG. 2. For example, the first electronic device (201) can further execute one or more programs including a natural language platform (250) and / or store a capsule database (260) while including components of the first electronic device (201) of FIG. 2.

[0042] The natural language platform (250) may include an automatic speech recognition module (251), a natural language understanding module (253), a planner module (255), a natural language generation module (257), and / or a text-to-speech module (259). The automatic speech recognition module (251), the natural language understanding module (253), the planner module (255), the natural language generation module (257), and the text-to-speech module (259) may perform functions identical to or similar to those of the automatic speech recognition module (221), the natural language understanding module (223), the planner module (225), the natural language generation module (227), and the text-to-speech module (229) of FIG. 2, respectively.

[0043] The capsule database (260) may perform functions identical to or similar to those of the capsule database (230) of the intelligent server (200, 202). The capsule database (260) may store information about relationships between multiple operations and multiple concepts included in a plan generated by the planner module (255). For example, the capsule database (260) may store at least one capsule (e.g., capsule (261) and / or capsule (263)22).

[0044] According to one embodiment, the electronic device (203) (e.g., the natural language platform (250) and / or capsule database (260)) and the intelligent server (202) (e.g., the natural language platform (220) and / or capsule database (230)) may perform at least one function (or operation) in conjunction with each other, or may independently perform at least one function (or operation). For example, the electronic device (203) may perform voice recognition on its own without transmitting the received user's voice input to the intelligent server (202). In one embodiment, the electronic device (203) may convert the received voice input into text data through the automatic voice recognition module (251). The electronic device (203) may transmit the converted text data to the intelligent server (202). The intelligent server (202) may determine (or identify) the user's intention and / or parameters from the text data through the natural language understanding module (223). The intelligent server (202) can generate a plan through the planner module (225) based on the determined intent and parameters and transmit the plan to the electronic device (203), or can transmit the determined intent and parameters to the electronic device (203) and cause the plan to be generated through the planner module (255) of the electronic device (203). The planner module (255) of the electronic device (203) can generate at least one plan for performing a task corresponding to a voice input using information stored in the capsule database (260).

[0045] In one embodiment, the electronic device (203) can convert voice input received through the automatic speech recognition module (251) into text data, and determine (or identify) the user's intent and / or parameters based on the text data through the natural language understanding module (253). The electronic device (203) can generate a plan through the planner module (255) based on the determined intent and parameters, or can transmit the determined intent and parameters to the intelligent server (202) so that the planner module (225) of the intelligent server (202) can generate a plan. For example, if the electronic device (203) does not include the planner module (255) and / or the capsule database (260), the electronic device (203) can generate a plan through the intelligent server (202).

[0046] In one embodiment, the electronic device (203) can detect a speech pattern that is difficult to learn in the automatic speech recognition module (251) or the natural language understanding module (253), and transmit a voice input corresponding to the detected speech pattern to the intelligent server (202) so that the automatic speech recognition module (221) or the natural language understanding module (223) of the intelligent server (202) can process it.

[0047] Embodiments of the present disclosure are not limited to the examples described above. For example, the electronic device (203) may process the received voice input only within the terminal and produce a result corresponding to the voice input. In one embodiment, the electronic device (203) and the intelligent server (202) may not only process the voice input by dividing it into modules, but may also collaborate with each other for processing. For example, the natural language understanding module (253) of the electronic device (203) and the natural language understanding module (223) of the intelligent server (202) may work together to produce a single result value (e.g., the user's intention and / or parameters).

[0048] FIG. 3 is a block diagram illustrating an electronic device (100) according to one embodiment of the present disclosure.

[0049] In one embodiment, the electronic device (100) may include a processor (110), memory (120), and a display (140).

[0050] In one embodiment, the memory (120) may include an image analysis unit (311), a skeleton inference and allocation unit (312), a skeleton control unit (313), a generation model (314), a prompt-based object deformation model (315), a depth generation unit (316), and a re-lighting unit (317). The memory (120) may store the image analysis unit (311), a skeleton inference and allocation unit (312), a skeleton control unit (313), a generation model (314), a prompt-based object deformation model (315), a depth generation unit (316), and a re-lighting unit (317).

[0051] In one embodiment, the instructions, program, or application may include an image analysis unit (311), a skeleton inference and allocation unit (312), a skeleton control unit (313), a generation model (314), a prompt-based object deformation model (315), a depth generation unit (316), and a re-lighting unit (317). The instructions, program, or application may include an image analysis unit (311), a skeleton inference and allocation unit (312), a skeleton control unit (313), a generation model (314), a prompt-based object deformation model (315), a depth generation unit (316), and a re-lighting unit (317).

[0052] However, it is not limited thereto, and the image analysis unit (311), skeleton inference and allocation unit (312), skeleton control unit (313), generation model (314), prompt-based object deformation model (315), depth generation unit (316), and re-lighting unit (317) can be embedded as instructions in the processor (110).

[0053] In one embodiment, the image analysis unit (311) may include generative artificial intelligence (AI). The skeleton inference and allocation unit (312) may include generative AI. The skeleton control unit (313) may include generative AI. The generative model (314) may include generative AI. The prompt-based object deformation model (315) may include generative AI. The depth generation unit (316) may include generative AI. The rewriting unit (317) may include generative AI.

[0054] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to identify object information in an image.

[0055] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to identify deformable objects and / or interactable objects in the image.

[0056] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to identify a deformable object and / or an interactable object in the image and to verify object information.

[0057] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to perform segmentation on an image.

[0058] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to detect and classify objects in an image through segmentation.

[0059] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to identify a deformable object and / or an interactable object among at least one object detected in the image.

[0060] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to perform learning to identify deformable objects and / or interactable objects through scene analysis.

[0061] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to identify a location and / or terrain included in an image.

[0062] In one embodiment, the deformable object may include, for example, at least one of an object whose position on the image can be moved, an object whose size can be changed, an object whose shape can be changed, or an object whose joints can be changed.

[0063] In one embodiment, the deformable object may include, for example, an object such as a living thing, such as an animal or a plant. However, the present invention is not limited thereto, and the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to identify terrain, a place, or a background in an image through scene analysis. The instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to recognize an object placed on terrain, a place (e.g., a building), or a background as a deformable object.

[0064] In one embodiment, an interactable object may include an object that can interact with a deformable object. An interactable object may include a deformable object.

[0065] In one embodiment, an interactable object may include an object that becomes the target of a state change when the state of a deformable object changes. For example, if the deformable object is a person, the person may change from standing to sitting in a chair. In this case, the chair may be the object that becomes the target of the state change and may be an interactable object.

[0066] In one embodiment, the instructions stored in the image analysis unit (311), when executed by the processor (110), may cause the electronic device (100) to first identify a deformable object and then identify other objects as interactable objects.

[0067] In one embodiment, instructions stored in the skeleton inference and allocation unit (312), when executed by the processor (110), may cause the electronic device (100) to generate skeleton information based on identified object information.

[0068] In one embodiment, the instructions stored in the skeleton inference and allocation unit (312), when executed by the processor (110), may cause the electronic device (100) to generate skeleton information as coordinate or position information. The skeleton information may include coordinate or position information. The instructions stored in the skeleton inference and allocation unit (312), when executed by the processor (110), may cause the electronic device (100) to store the skeleton information as meta information in the memory (120).

[0069] In one embodiment, instructions stored in the skeleton inference and allocation unit (312), when executed by the processor (110), may cause the electronic device (100) to assign generated skeleton information to an object.

[0070] In one embodiment, the instructions stored in the skeleton inference and allocation unit (312), when executed by the processor (110), may cause the electronic device (100) to generate skeleton information for a deformable object and to assign the generated skeleton information to the deformable object.

[0071] In one embodiment, the instructions stored in the skeleton inference and allocation unit (312), when executed by the processor (110), may cause the electronic device (100) to generate skeleton information by applying a skeleton inference algorithm from a deformable object.

[0072] In one embodiment, the instructions stored in the skeleton inference and allocation unit (312), when executed by the processor (110), may cause the electronic device (100) to receive user input for a deformable object and generate skeleton information. For example, the user input may include a drawing input. The instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to display a user interface capable of receiving the drawing input.

[0073] In one embodiment, instructions stored in the skeleton control unit (313), when executed by the processor (110), may cause the electronic device (100) to provide a user interface that can control the skeleton based on the skeleton information.

[0074] In one embodiment, the skeleton information may include graphical objects.

[0075] In one embodiment, a graphical object may be displayed on the display (140). Upon receiving a user input, instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to move a link interface and / or a joint interface included in the graphical object. For example, the user input may include a drag input. The instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to display the link interface and / or joint interface moved according to the user input on the display (140). The instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to display a graphical object corresponding to depth information of an object corresponding to a skeleton based on depth information of an image.

[0076] In one embodiment, a graphical object may be displayed on the display (140). Upon receiving user input, instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to change the angle between the link interfaces.

[0077] In one embodiment, a graphical object may be displayed on a display (140). Upon receiving user input, instructions stored in memory (120), when executed by the processor (110), may cause the electronic device (100) to change the length of a link interface (e.g., to make the link longer or shorter than the original link).

[0078] For example, if the deformable object is a television, the instructions stored in the memory (120), when executed by the processor (110), can cause the electronic device (100) to display a link interface surrounding the television as a graphic object. In this case, by increasing or decreasing the length of the link interface, the size of the deformable object, the television, can be changed.

[0079] In one embodiment, a graphical object may be displayed on a display (140). Upon receiving user input, instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to move a graphical object or an object included in an image (e.g., a changeable object or an interactive object).

[0080] In one embodiment, when moving a graphical object or an object included in an image (e.g., a mutable object or an interactable object), instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to determine whether it is paired with the surrounding terrain or location, and to correct the object included in the image (e.g., a mutable object or an interactable object) so that it can be paired.

[0081] In one embodiment, when moving a graphic object or an object included in an image (e.g., a mutable object or an interactable object), instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to perform scene analysis, determine whether objects interact based on the scene analysis, and correct objects included in the image (e.g., mutable objects or interactable objects) so that the objects can interact.

[0082] In one embodiment, when moving a graphic object or an object included in an image (e.g., a mutable object or an interactable object), instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to perform scene analysis, determine whether there is pairing between objects based on the scene analysis, and correct the objects included in the image (e.g., a mutable object or an interactable object) so that they can be paired.

[0083] In one embodiment, when moving a graphic object or an object included in an image (e.g., a mutable object or an interactable object), instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to determine whether pairing occurs between the objects and to correct the objects included in the image (e.g., a mutable object or an interactable object) so that they can be paired.

[0084] In one embodiment, if the object included in the image (e.g., a changeable object or an interactable object) is a chair, and the chair is moved by user input and moves away from the floor, instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to increase the length of the chair so that it can pair with the floor and adjust the length of the chair so that it touches the floor.

[0085] In one embodiment, if the object included in the image (e.g., a changeable object or an interactable object) is a chair, and the chair is moved by user input and moves away from the floor, instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to increase the length of the chair so that it can interact with the floor and adjust the length of the chair so that it touches the floor.

[0086] In one embodiment, a graphical object may include at least one link interface or a plurality of link interfaces. The graphical object may include at least one joint interface connecting the link interfaces.

[0087] However, this is not limited to the graphical object, and the graphical object may include a joint interface based on a deformable object.

[0088] In one embodiment, the generative model (314) can generate an image that includes an object corresponding to a graphical object.

[0089] In one embodiment, the instructions stored in the generative model (314), when executed by the processor (110), may cause the electronic device (100) to change an object on an image based on a graphical object.

[0090] In one embodiment, the instructions stored in the generation model (314), when executed by the processor (110), may cause the electronic device (100) to generate an image including a modified object based on a graphical object.

[0091] However, this is not limited thereto, and the instructions stored in the generation model (314), when executed by the processor (110), may cause the electronic device (100) to generate an image including an object that has interacted with a changed object based on a graphical object.

[0092] However, the present invention is not limited thereto, and the instructions stored in the generation model (314), when executed by the processor (110), can cause the electronic device (100) to generate an image in which the shape of a deformed object (e.g., a person to a person) is deformed based on a graphic object. For example, an image in which people (deformable objects) are changed from a standing state to a state of embracing each other can be generated.

[0093] In one embodiment, the instructions stored in the generative model (314), when executed by the processor (110), may cause the electronic device (100) to generate an image replicating a mutable object or an interactable object.

[0094] In one embodiment, the instructions stored in the generation model (314), when executed by the processor (110), may cause the electronic device (100) to change an object corresponding to a changed graphical object according to user input and generate an image including the changed object.

[0095] In one embodiment, instructions stored in a prompt-based object deformation model (315), when executed by a processor (110), may cause the electronic device (100) to correct a graphical object and / or an image generated via the generation model (314) using a prompt. The prompt may include, for example, a question or command prompting the user to perform a specific task.

[0096] In one embodiment, the instructions stored in the prompt-based object deformation model (315), when executed by the processor (110), may cause the electronic device (100) to modify an image generated through the graphical object and / or generation model (314) and the prompt to correspond to a user's intent so as to produce a result in which the object is deformed as intended by the user. The intent may include a goal or direction that the user wishes to achieve through the image and / or prompt.

[0097] In one embodiment, the instructions stored in the prompt-based object deformation model (315), when executed by the processor (110), may cause the electronic device (100) to modify a graphical object and / or a generated image through the generation model (314) based on prompts describing actions or behaviors that an object included in the image may take.

[0098] In one embodiment, the prompt-based object deformation model (315) can modify the image based on the graphical object and / or generated image and prompt through the generation model (314) to correspond to the user's intent so that the object can be deformed as intended by the user.

[0099] In one embodiment, a prompt-based object deformation model (315) can use prompts to correct graphical objects and / or generated images via a generation model (314).

[0100] In one embodiment, a prompt-based object deformation model (315) can correct graphical objects and / or generated images via a generative model (314) based on prompts that describe actions or behaviors that objects contained in the image can take.

[0101] In one embodiment, the prompt may be obtained through a prompt input interface.

[0102] In one embodiment, instructions stored in the prompt-based object deformation model (315), when executed by the processor (110), may cause the electronic device (100) to obtain a prompt through a prompt input interface.

[0103] In one embodiment, the prompt may comprise a sentence in natural language. The prompt may comprise image input, text input, or speech input.

[0104] In one embodiment, instructions stored in the prompt-based object transformation model (315), when executed by the processor (110), may cause the electronic device (100) to extract prompts from sentences composed of natural language.

[0105] In one embodiment, the instructions stored in the depth information generation module (316), when executed by the processor (110), may cause the electronic device (100) to generate a depth map for an image to be edited. The depth information generation module (316) may include not only generative AI but also general AI. The depth map may include information related to the surface distance of an object included in the image from a viewpoint. The depth information generation module (316) may be an artificial intelligence trained to calculate depth information from a single image.

[0106] In one embodiment, the depth information may include information acquired using a sensor that acquires depth information when capturing an image (e.g., lidar or time of flight (ToF)). The depth information may be stored in metadata within the image.

[0107] In one embodiment, the instructions stored in the depth information generation module (316), when executed by the processor (110), may cause the electronic device (100) to update depth information of an image based on changes and / or movements of objects within the image.

[0108] In one embodiment, the instructions stored in the re-lighting unit (317), when executed by the processor (110), may cause the electronic device (100) to adjust light and / or shadows corresponding to a moved object when the object is changed or moved in the image by user input.

[0109] In one embodiment, the instructions stored in the relighting unit (317), when executed by the processor (110), may cause the electronic device (100) to repeatedly adjust light and / or shadows in response to a changed or moved object.

[0110] In one embodiment, the instructions stored in the rewriting unit (317), when executed by the processor (110), may cause the electronic device (100) to preview an image with adjusted lighting and / or shadows corresponding to a changed or moved object.

[0111] In one embodiment, the instructions stored in the relighting unit (317), when executed by the processor (110), may cause the electronic device (100) to perform operations that adjust light and / or shadows on a background image based on the moved object position and updated depth information as the object changes.

[0112] In one embodiment, the memory (120) may further include an out painting / in painting section (not shown).

[0113] In one embodiment, the instructions stored in the outpainting / inpainting unit, when executed by the processor (110), may cause the electronic device (100) to identify a first region on the image in which a movable object identified in the image is to be emptied as it moves in position, and / or a second region in which a movable object identified in the image is to be created as it moves in position.

[0114] In one embodiment, the instructions stored in the outpainting / inpainting unit, when executed by the processor (110), may cause the electronic device (100) to perform a filling operation based on objects and / or pixels recognized or detected in the image for the first region and the second region. The filling operation may include adding recognized or detected objects and / or pixels to the region to be filled.

[0115] In one embodiment, the instructions stored in the outpainting / inpainting module, when executed by the processor (110), may cause the electronic device (100) to determine that a portion of a movable object has moved outside the image boundary. The instructions stored in the outpainting / inpainting module, when executed by the processor (110), may cause the electronic device (100) to perform an operation of displaying the entire shape of the movable object when a portion of the movable object has moved outside the image boundary. In one embodiment, the instructions stored in the outpainting / inpainting module, when executed by the processor (110), may cause the electronic device (100) to analyze an area of ​​an original image that requires expansion so that the electronic device (100) can display the entire shape of the moved object based on the original image size (e.g., resolution), and perform outpainting on the determined area that requires expansion.

[0116] FIG. 4 is a flowchart illustrating an image editing method of an electronic device (100) according to one embodiment of the present disclosure.

[0117] In one embodiment, the memory (120) can store instructions. The instructions stored in the memory (120) can cause the electronic device (100) to perform the image letter method of FIG. 4.

[0118] In one embodiment, in operation 401, instructions stored in memory (120) may cause the electronic device (100) to display an image on a display (140). The image may include at least one object.

[0119] In one embodiment, in operation 401, instructions stored in memory (120) may cause the electronic device (100) to display an image including at least one object through the display (140).

[0120] For example, the image may include an image stored in an image gallery by the user. The image may be acquired through an image sensor (150) included in the electronic device (100). The image may be acquired through a communication circuit (160) included in the electronic device (100).

[0121] In one embodiment, in operation 401, instructions stored in memory (120) may cause the electronic device (100) to display an image on a display (140) via an image editing interface. The image editing interface may receive a user's touch input to change an object included in the image, skeleton information corresponding to the object, or a graphic object corresponding to the object, and display the changed object on the display (140).

[0122] In one embodiment, in operation 403, instructions stored in memory (120) may cause the electronic device (100) to identify object information in an image.

[0123] In one embodiment, in operation 403, instructions stored in memory (120) may cause the electronic device (100) to identify a deformable object and / or an interactable object on an image and to verify object information.

[0124] In one embodiment, in operation 403, instructions stored in memory (120) may cause the electronic device (100) to perform segmentation on an image.

[0125] In one embodiment, in operation 403, instructions stored in memory (120) may cause the electronic device (100) to recognize and classify objects through segmentation in an image.

[0126] In one embodiment, in operation 403, instructions stored in the memory (120) may cause the electronic device (100) to identify a deformable object and / or an interactable object among at least one object detected in the image.

[0127] In one embodiment, in operation 403, instructions stored in memory (120) may cause the electronic device (100) to perform learning to identify deformable objects and / or interactable objects through scene analysis.

[0128] In one embodiment, at operation 403, instructions stored in memory (120) may cause the electronic device (100) to identify locations and / or terrain included in the image.

[0129] In one embodiment, in operation 403, instructions stored in memory (120) may cause the electronic device (100) to first identify a deformable object and then identify other objects as interactable objects.

[0130] In one embodiment, at operation 405, instructions stored in memory (120) may cause the electronic device (100) to generate skeleton information based on object information.

[0131] In one embodiment, at operation 405, instructions stored in memory (120) may cause the electronic device (100) to generate skeleton information based on the identified object information.

[0132] In one embodiment, at operation 405, instructions stored in memory (120) may cause the electronic device (100) to generate skeleton information for a deformable object and assign the generated skeleton information to the deformable object.

[0133] In one embodiment, at operation 405, instructions stored in memory (120) may cause the electronic device (100) to generate skeleton information by applying a skeleton inference algorithm from a deformable object.

[0134] In one embodiment, at operation 405, instructions stored in memory (120) may cause the electronic device (100) to receive user input for a deformable object and generate skeleton information.

[0135] In one embodiment, at operation 405, the instructions stored in the memory (120) may cause the electronic device (100) to display a user interface capable of receiving drawing input. The instructions stored in the memory (120) may cause the electronic device (100) to receive the drawing input and generate skeleton information.

[0136] In one embodiment, operations 403 and 405 may be combined. In one embodiment, in operation 405, instructions stored in memory (120) may cause the electronic device (100) to generate skeleton information based on object information, at least in part based on a determination that at least one object corresponds to a deformable object.

[0137] In one embodiment, at operation 407, instructions stored in memory (120) may cause the electronic device (100) to display a graphical object corresponding to the skeleton information through the display (140).

[0138] In one embodiment, at operation 407, instructions stored in memory (120) may cause the electronic device (100) to display a graphic object corresponding to the skeleton information by overlaying it on at least one object.

[0139] In one embodiment, at operation 407, instructions stored in memory (120) may cause the electronic device (100) to provide a user interface that can control the skeleton based on the skeleton information.

[0140] In one embodiment, the skeleton information may include graphical objects.

[0141] In one embodiment, a graphical object may be displayed on a display (140). Upon receiving a user input, instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to move a link interface and / or a joint interface included in the graphical object. For example, the user input may include a drag input. The instructions stored in the memory (120), when executed by the processor (110), may cause the electronic device (100) to display the link interface and / or joint interface moved according to the user input on the display (140).

[0142] In one embodiment, a graphical object may include at least one link interface or a plurality of link interfaces. The graphical object may include at least one joint interface connecting the link interfaces.

[0143] However, this is not limited to the graphical object, and the graphical object may include a joint interface based on a deformable object.

[0144] In one embodiment, at operation 409, instructions stored in memory (120) may cause the electronic device (100) to determine whether user input has been received.

[0145] Upon receiving user input, instructions stored in memory (120) can cause the electronic device (100) to branch from operation 409 to operation 411.

[0146] If no user input is received, the instructions stored in the memory (120) may cause the electronic device (100) to branch from operation 409 to operation 407.

[0147] In one embodiment, at operation 411, instructions stored in memory (120) may cause the electronic device (100) to modify a graphical object based on user input.

[0148] In one embodiment, at operation 413, instructions stored in memory (120) may cause the electronic device (100) to display a modified graphic object through a display (140).

[0149] In one embodiment, at operation 413, instructions stored in memory (120) may cause the electronic device (100) to display a changed object based on the modified graphic object.

[0150] In one embodiment, at operation 413, instructions stored in memory (120) may cause the electronic device (100) to change an object on an image based on a graphic object.

[0151] In one embodiment, at operation 413, instructions stored in memory (120) may cause the electronic device (100) to generate an image including a modified object based on a graphic object.

[0152] In one embodiment, at operation 415, instructions stored in memory (120) may cause the electronic device (100) to generate a prompt based on the modified graphical object and image.

[0153] In one embodiment, at operation 415, instructions stored in memory (120) may cause the electronic device (100) to extract a prompt related to a modified graphical object or a changed object.

[0154] In one embodiment, at operation 415, instructions stored in memory (120) may cause the electronic device (100) to extract a prompt describing an action or behavior that an object included in the image may take.

[0155] In one embodiment, at operation 415, instructions stored in memory (120) may cause the electronic device (100) to obtain a prompt through a prompt input interface.

[0156] In one embodiment, the prompt may comprise a sentence in natural language. The prompt may comprise image input, text input, or speech input.

[0157] In one embodiment, at operation 415, instructions stored in memory (120) may cause the electronic device (100) to extract a prompt from a sentence composed of natural language.

[0158] In one embodiment, at operation 417, instructions stored in memory (120) may cause the electronic device (100) to generate an image based on the prompt and the changed object.

[0159] In one embodiment, in operation 417, instructions stored in memory (120) may cause the electronic device (100) to generate an AI image based on a prompt using an AI model. The AI ​​model may include, for example, one or more of an image analysis unit (311), a skeleton inference and allocation unit (312), a skeleton control unit (313), a generation model (314), a prompt-based object deformation unit (315), a depth generation unit (316), or a re-lighting unit (317).

[0160] In one embodiment, at operation 417, instructions stored in memory (120) may cause the electronic device (100) to correct an image generated via a graphical object and / or a generation model (314) using a prompt.

[0161] In one embodiment, at operation 417, instructions stored in memory (120) may cause the electronic device (100) to modify an image generated through a graphical object and / or a generation model (314) and a prompt to correspond to a user's intent so that the object can be transformed as intended by the user.

[0162] In one embodiment, at operation 417, instructions stored in memory (120) may cause the electronic device (100) to correct a graphical object and / or a generated image through a generative model (314) based on a prompt describing an action or behavior that an object included in the image may take.

[0163] In one embodiment, when generating an image based on a prompt and a changed object, in operation 417, instructions stored in memory (120) may cause the electronic device (100) to change depth information for the changed object.

[0164] In one embodiment, when generating an image based on a prompt and a changed object, at operation 417, instructions stored in memory (120) may cause the electronic device (100) to perform rewriting of the changed object.

[0165] In one embodiment, when generating an image based on a prompt and a changed object, at operation 417, instructions stored in memory (120) may cause the electronic device (100) to perform an out-painting / in-painting operation on the changed object.

[0166] However, it is not limited thereto, and in the image editing method of the electronic device (100) of FIG. 4, operations 415 and 417 may be omitted.

[0167] FIG. 5 is a drawing showing an image editing method of an electronic device (100) according to one embodiment of the present disclosure.

[0168] In screen 501, instructions stored in memory (120) can cause the electronic device (100) to display a first image (510) on the display (140). The first image (510) can be displayed on an image editing interface.

[0169] For example, the first image (510) may include at least one object (511, 512). The first image (510) may include a wall (511) and a person (512) as objects.

[0170] In screen 501, instructions stored in memory (120) can cause the electronic device (100) to recognize and classify at least one object (511, 512) through segmentation in the first image (510).

[0171] In screen 501, instructions stored in memory (120) can cause the electronic device (100) to identify a deformable object (512) and an interactable object (511) among at least one object (511, 512) detected in the first image (510).

[0172] For example, a deformable object (e.g., a person (512)) may include at least one of an object whose position on the first image (510) can be moved, an object whose size can be changed, an object whose joints can be deformed, or an object whose joints can be deformed.

[0173] For example, an interactable object (e.g., a wall (511)) may include an object that can interact with a deformable object (e.g., a person (512)). The interactable object (e.g., the wall (511)) may include a deformable object. The interactable object (e.g., the wall (511)) may include an object that becomes the target of the state change when the state of the deformable object changes. For example, if the deformable object is a person (512), the person (512) may change from a standing state to a leaning state against the wall (511). The subject of the state change may be the person (512), and the target of the state change may be the wall (511). The deformable object (e.g., the person (512)) may include the subject of the state change, and the interactable object (e.g., the wall (511)) may include the target of the state change.

[0174] On screen 502, instructions stored in memory (120) may cause the electronic device (100) to overlay a graphic object (520) on a deformable object (e.g., a person (512)) and display it on the display (140).

[0175] On screen 502, instructions stored in memory (120) can cause the electronic device (100) to automatically overlay a graphic object (520) and display it on the display (140) when a deformable object (e.g., a person (512)) is identified.

[0176] However, it is not limited thereto, and in screen 502, the instructions stored in the memory (120) can cause the electronic device (100) to display a graphic object display icon (530) on the display (140). When a user input is received for the graphic object display icon (530), the instructions stored in the memory (120) can cause the electronic device (100) to overlay a graphic object (520) on a deformable object (e.g., a person (512)) and display it on the display (140).

[0177] On screen 502, instructions stored in memory (120) cause the electronic device (100) to not display the graphic object (520) when receiving a user input for the graphic object display icon (530) while displaying the graphic object (520) by overlaying it on a deformable object (e.g., a person (512)).

[0178] On the screen 502, the instructions stored in the memory (120) may cause the electronic device (100) to infer skeletal information for a deformable object (e.g., a person (512)) and display a notification that the inference is complete on a graphical object display icon (530). For example, the notification that the inference is complete may include an action of highlighting and displaying the graphical object display icon (530). The instructions stored in the memory (120) may cause the electronic device (100) to overlay a graphical object (520) on a deformable object (e.g., a person (512)) based on the inferred skeletal information.

[0179] On screen 503, instructions stored in memory (120) can cause the electronic device (100) to receive user input for a graphic object (520).

[0180] On screen 503, instructions stored in memory (120) can cause the electronic device (100) to change the shape of a graphic object (520) according to user input.

[0181] On the screen 503, the instructions stored in the memory (120) can cause the electronic device (100) to move a link interface and / or a joint interface included in a graphic object (520). For example, the user input can include a drag input. The instructions stored in the memory (120), when executed by the processor (110), can cause the electronic device (100) to display the link interface and / or joint interface moved according to the user input on the display (140). The instructions stored in the memory (120), when executed by the processor (110), can cause the electronic device (100) to display a graphic object change process (e.g., change in position, etc.) on the screen in real time while changing the graphic object.

[0182] On screen 503, instructions stored in memory (120) may provide a user interface that controls a variable position so that the electronic device (100) can move only within a movable area, taking into account the characteristics of the current object (e.g., person (512)).

[0183] In screen 503, instructions stored in memory (120) may cause the electronic device (100) to change the position of a deformable object (e.g., a person (512)) on the image so that the deformable object (e.g., a person (512)) and the interactable object (e.g., a wall (511)) can be paired or contacted with each other without the movement of the graphic object (520) completely contacting the interactable object (e.g., a wall (511)). The pairing operation may include, for example, performing an interaction between the objects.

[0184] In the 503 screen, the instructions stored in the memory (120) can cause the electronic device (100) to change the position of the deformable object (e.g., person (512)) on the image so that the deformable object (e.g., person (512)) and the deformable object (e.g., wall (511)) can interact or contact each other without the movement of the graphic object (520) completely contacting the reactive object (e.g., wall (511)).

[0185] For example, the position of a person (512) on the image can be changed so that the person (512) and the wall (511) can be paired or contacted even if the hand-shaped link interface of the graphic object (520) does not completely contact the wall (511).

[0186] For example, the position of a person (512) on the image can be changed so that the person (512) and the wall (511) can interact or come into contact even if the hand-shaped link interface of the graphic object (520) does not completely contact the wall (511).

[0187] On screen 504, instructions stored in memory (120) can cause the electronic device (100) to generate an image including a changed object (e.g., a person (512)) based on the movement of a graphic object (520).

[0188] In one embodiment, skeleton information (or location, coordinate information) of a changed object (e.g., a person (512)) may be stored in memory (120) as meta information.

[0189] On screen 504, instructions stored in memory (120) may cause the electronic device (100) to extract a prompt and generate an image including a changed object (e.g., a person (512)) based on the extracted prompt and / or movement of a graphic object (520).

[0190] For example, when the movement of the graphic object (520) is such that it does not completely contact an interactive object (e.g., a wall (511)), an image of a changed object (e.g., a person (512)) putting its hand on the wall (511) can be generated based on the extracted prompt and / or the movement of the graphic object (520). The user can input "Generate an image of a person leaning against a wall" as the prompt. The instructions stored in the memory (120) can cause the electronic device (100) to extract the prompt and, based on the extracted prompt and / or the movement of the graphic object (520), generate an image of a changed object (e.g., a person (512)) putting its hand on the wall (511).

[0191] On screen 504, the instructions stored in the memory (120) may cause the electronic device (100) to display a graphic object display icon (530) on the first image (510) in which the generated image or object has been changed, on the display (140). Upon receiving a user input to the graphic object display icon (530), the instructions stored in the memory (120) may cause the electronic device (100) to redisplay the graphic object (520) on the deformable object (e.g., the person (512)) and edit the first image (510). Alternatively, upon receiving a user input to the graphic object display icon (530), the instructions stored in the memory (120) may cause the electronic device (100) to display the graphic object (520) on the original image (510).

[0192] In one embodiment, the image containing the changed object and the original image may be stored in memory (120).

[0193] FIG. 6 is a drawing showing an image editing method of an electronic device (100) according to one embodiment of the present disclosure.

[0194] On screen 601, instructions stored in memory (120) can cause the electronic device (100) to display a second image (610) on the display (140). The second image (610) can be displayed on an image editing interface.

[0195] For example, the second image (610) may include at least one object (611, 612, 613). The second image (610) may include a person (611), a bench (612), and dumbbells (613) as objects.

[0196] In screen 601, instructions stored in memory (120) can cause the electronic device (100) to recognize and classify at least one object (611, 612, 613) through segmentation in the second image (610).

[0197] In screen 601, instructions stored in memory (120) can cause the electronic device (100) to identify a deformable object (611) and an interactable object (612, 613) among at least one object (611, 612, 613) detected in the second image (610).

[0198] For example, a deformable object (e.g., a person (611)) may include at least one of an object whose position can be moved on the second image (610), an object whose size can be changed, an object whose joints can be deformed, or an object whose joints can be deformed.

[0199] For example, an interactable object (e.g., a bench (612), dumbbells (613)) may include an object that can interact with a deformable object (e.g., a person (611)). The interactable object (e.g., a bench (612), dumbbells (613)) may include a deformable object. The interactable object (e.g., a bench (612), dumbbells (613)) may include an object that becomes a target of a state change when the state of the deformable object changes. For example, if the deformable object is a person (611), the state may change from a state where the person (611) is lying on the bench (612) to a state where the dumbbells (613) are pulled and then pushed. The subject of the state change may be the person (611), and the target of the state change may be the bench (612) or the dumbbells (613). A deformable object (e.g., a person (611)) may include a subject of a state change, and an interactable object (e.g., a bench (612), dumbbells (613)) may include a target of a state change.

[0200] On screen 602, instructions stored in memory (120) can cause the electronic device (100) to overlay a graphic object (620) on a deformable object (e.g., a person (611)) and display it on the display (140).

[0201] On the 602 screen, the instructions stored in the memory (120) can cause the electronic device (100) to automatically overlay a graphic object (620) and display it on the display (140) when it identifies a deformable object (e.g., a person (611)).

[0202] However, this is not limited thereto, and in screen 602, instructions stored in memory (120) can cause the electronic device (100) to receive drawing input and draw and display a graphic object (620) on a deformable object (e.g., a person (611)).

[0203] On screen 603, instructions stored in memory (120) can cause the electronic device (100) to receive user input for a graphic object (620).

[0204] On the 603 screen, instructions stored in the memory (120) can cause the electronic device (100) to change the shape of the graphic object (620) according to user input.

[0205] On screen 603, instructions stored in memory (120) may cause the electronic device (100) to move a link interface and / or joint interface included in a graphic object (620). For example, the user input may include a drag input.

[0206] On the 603 screen, the instructions stored in the memory (120) can cause the electronic device (100) to highlight and display the skeleton moved by the user's selection among the graphic objects (620) and display the remaining skeletons semi-transparently.

[0207] For example, if only the skeleton for the arm holding the dumbbells (613) is moved by user input, only the skeleton for the arm can be highlighted and displayed, and the remaining skeletons can be displayed semi-transparently.

[0208] On screen 603, instructions stored in memory (120) can provide a user interface that controls a variable position so that the electronic device (100) can move only within a movable area, taking into account the characteristics of the current object (e.g., person (611)).

[0209] On screen 604, instructions stored in memory (120) can cause the electronic device (100) to generate an image including a changed object (e.g., a person (611)) based on the movement of a graphic object (620).

[0210] On the screen 604, the instructions stored in the memory (120) may cause the electronic device (100) to generate an image by moving together, among the interactable objects (e.g., bench (612), dumbbells (613)), a deformable object (611) and an object that must move to create a natural expression of the deformed object or an object that must interact with each other (e.g., dumbbells (613)). On the screen 604, the instructions stored in the memory (120) may cause the electronic device (100) to generate an image by moving together, among the interactable objects (e.g., bench (612), dumbbells (613)), a deformable object (611) and an object that must move to create a natural expression of the deformed object or an object that can interact with each other (e.g., dumbbells (613)).

[0211] In one embodiment, skeleton information (or location, coordinate information) of a changed object (e.g., a person (611)) may be stored in memory (120) as meta information. Skeleton information (or location, coordinate information) of a changed object (e.g., a person (611)) may be stored in memory (120) as meta information in a file of a generated image.

[0212] On screen 604, instructions stored in memory (120) may cause the electronic device (100) to extract a prompt and generate an image including a changed object (e.g., a person (611)) based on the extracted prompt and / or movement of the graphic object (520).

[0213] For example, an image of a modified object (e.g., a person (611)) lifting dumbbells (613) can be generated based on the extracted prompt and / or movement of the graphic object (520). A user may input "generate an image of a person lifting dumbbells" as a prompt. Instructions stored in the memory (120) can cause the electronic device (100) to extract the prompt and generate an image of a modified object (e.g., a person (611)) lifting dumbbells (613) based on the extracted prompt and / or movement of the graphic object (520).

[0214] In one embodiment, the image containing the changed object and the original image may be stored in memory (120).

[0215] FIG. 7a and FIG. 7b are drawings showing an image editing method of an electronic device (100) according to one embodiment of the present disclosure.

[0216] In screen 701, instructions stored in memory (120) can cause the electronic device (100) to display a third image (710) on the display (140). The third image (710) can be displayed on an image editing interface.

[0217] For example, the third image (710) may include at least one object (711, 712). The third image (710) may include a person (711) and a chair (712) as objects.

[0218] In screen 701, instructions stored in memory (120) can cause the electronic device (100) to recognize and classify at least one object (711, 712) through segmentation in the third image (710).

[0219] In screen 701, instructions stored in memory (120) can cause the electronic device (100) to identify a deformable object (711) and an interactable object (712) among at least one object (711, 712) detected in the third image (710).

[0220] For example, a deformable object (e.g., a person (711)) may include at least one of an object whose position can be moved on the third image (710), an object whose size can be changed, an object whose joints can be deformed, or an object whose joints can be deformed.

[0221] For example, an interactable object (e.g., a chair (712)) may include an object that can interact with a deformable object (e.g., a person (711)). The interactable object (e.g., a chair (712)) may include an object that becomes a target of a state change when the state of the deformable object changes. For example, if the deformable object is a person (711), the person (711) may change from a standing state to a sitting state on the chair (712). The subject of the state change may be the person (711), and the target of the state change may be the chair (712). The deformable object (e.g., a person (711)) may include a subject of the state change, and the interactable object (e.g., a chair (712)) may include a target of the state change.

[0222] In the 702 screen, the instructions stored in the memory (120) can cause the electronic device (100) to display a graphic object display icon (530) on the display (140). When a user input is received for the graphic object display icon (530), the instructions stored in the memory (120) can cause the electronic device (100) to overlay a graphic object (520) on a deformable object (e.g., a person (711)) and display it on the display (140).

[0223] On screen 702, instructions stored in memory (120) can cause the electronic device (100) to infer skeletal information for a deformable object (e.g., a person (711)) and display a notification that inference is complete on a graphic object display icon (530).

[0224] On screen 703, instructions stored in memory (120) can cause the electronic device (100) to move a deformable object (e.g., a person (711)) based on user input.

[0225] On screen 703, instructions stored in memory (120) can cause the electronic device (100) to overlay a moved deformable object (e.g., a person (711)) onto a specific object.

[0226] On screen 703, instructions stored in memory (120) can cause the electronic device (100) to move and display a deformable object (e.g., a person (711)) as an interactable object (712) based on user input.

[0227] In the 703 screen, the instructions stored in the memory (120) can cause the electronic device (100) to determine whether a specific object is an object that can interact with the deformable object (e.g., the person (711)) when the deformable object (e.g., the person (711)) moves toward the specific object based on a user input. If the user input is a long press or a touch input, the instructions stored in the memory (120) can cause the electronic device (100) to determine that the deformable object (e.g., the person (711)) is selected. The deformable object (e.g., the person (711)) can be moved on the third image (710) according to the user input (e.g., a drag input).

[0228] If a particular object is an object that can interact with a deformable object (e.g., a person (711)), then on screen 703, the instructions stored in the memory (120) can cause the electronic device (100) to display a user interface (or visual effect) around the interactable object (e.g., a chair (712)) indicating that the particular object is an interactable object.

[0229] If a specific object is an object that can interact with a deformable object (e.g., a person (711)), then in screen 704, the instructions stored in the memory (120) can cause the electronic device (100) to generate an image by changing the motion or shape of the deformable object (e.g., the person (711)) to a deformable state according to the interactable object (e.g., the chair (712)) when the deformable object (e.g., the person (711)) is moved over the interactable object (e.g., the chair (712)).

[0230] In one embodiment, instructions stored in memory (120) may cause the electronic device (100) to determine a form of interaction between a deformable object (e.g., a person (711)) and an interactable object (e.g., a chair (712)).

[0231] For example, when a deformable object (e.g., a person (711)) in a standing state is displayed as an overlay on an interactable object (e.g., a chair (712)), instructions stored in the memory (120) can cause the electronic device (100) to change the motion or shape of the deformable object (e.g., the person (711)) into a form (e.g., sitting) in which the deformable object (e.g., the person (711)) interacts with the interactable object (e.g., the chair (712)) to generate an image.

[0232] For example, when a deformable object in a standing state (e.g., a person (711)) is displayed as an overlay on an interactable object (e.g., a chair (712)), instructions stored in the memory (120) can cause the electronic device (100) to determine an interactable shape or an interactable action between the deformable object (e.g., the person (711)) and the interactable object (e.g., the chair (712)). The interactable shape or the interactable action can include, for example, a shape or action of sitting on the interactable object (e.g., the chair (712)).

[0233] On screen 705, instructions stored in memory (120) can cause the electronic device (100) to receive user input on a graphic object display icon (530).

[0234] Upon receiving user input on the graphic object display icon (530), on screen 706, instructions stored in the memory (120) may cause the electronic device (100) to overlay a graphic object (720) on a deformable object (e.g., a person (711)) and display it on the display (140).

[0235] On screen 706, instructions stored in memory (120) can cause the electronic device (100) to receive user input for a graphic object (720).

[0236] On the 707 screen, instructions stored in the memory (120) can cause the electronic device (100) to change the shape of the graphic object (720) according to user input.

[0237] On the screen 707, the instructions stored in the memory (120) can cause the electronic device (100) to move a link interface and / or a joint interface included in a graphic object (720). For example, the user input can include a drag input. The instructions stored in the memory (120), when executed by the processor (110), can cause the electronic device (100) to display the link interface and / or joint interface moved according to the user input on the display (140).

[0238] On screen 707, instructions stored in memory (120) can provide a user interface that controls a variable position so that the electronic device (100) can move only within a movable area, taking into account the characteristics of the current object (e.g., person (711)).

[0239] On the 707 screen, instructions stored in the memory (120) can cause the electronic device (100) to provide one or more candidate results reflecting various depth information on the screen based on the link interface changed by the user input, and the link interface change can be confirmed by the user's selection.

[0240] For example, the foot-shaped link interface of the graphic object (720) can be moved and changed from a bent state to an unfolded state according to user input.

[0241] On screen 708, instructions stored in memory (120) can cause the electronic device (100) to generate an image including a changed object (e.g., a person (711)) based on the movement of a graphic object (720).

[0242] In one embodiment, skeleton information (or location, coordinate information) of a changed object (e.g., a person (711)) may be stored in memory (120) as meta information.

[0243] On screen 708, instructions stored in memory (120) may cause the electronic device (100) to extract a prompt and generate an image including a changed object (e.g., a person (711)) based on the extracted prompt and / or movement of a graphic object (720).

[0244] For example, the instructions stored in the memory (120) may cause the electronic device (100) to generate an image of a modified object (e.g., a person (711)) sitting on a chair (712) and stretching out one leg based on the extracted prompt and / or movement of the graphic object (720). A user may input a prompt such as "Generate an image of a person sitting on a chair and stretching out one leg (or right leg)". The instructions stored in the memory (120) may cause the electronic device (100) to extract the prompt and generate an image of a modified object (e.g., a person (711)) sitting on a chair (712) and stretching out its right leg based on the extracted prompt and / or movement of the graphic object (520).

[0245] In one embodiment, when the electronic device (100) generates an image based on the extracted prompt and the movement of the graphic object (520), rather than editing the image by inputting only one of the extracted prompt or the movement of the graphic object (520), the user's intention can be accurately reflected in the image editing.

[0246] On the screen 708, the instructions stored in the memory (120) may cause the electronic device (100) to display a graphic object display icon (530) on the third image (710) in which the generated image or object is changed on the display (140). Upon receiving a user input on the graphic object display icon (530), the instructions stored in the memory (120) may cause the electronic device (100) to display the graphic object (720) again on the deformable object (e.g., the person (711)) and edit the third image (710). Alternatively, upon receiving a user input on the graphic object display icon (530), the instructions stored in the memory (120) may cause the electronic device (100) to display the graphic object (720) on the original image (710).

[0247] In one embodiment, the image containing the changed object and the original image may be stored in memory (120).

[0248] FIG. 8 is a drawing showing an image editing method of an electronic device (100) according to one embodiment of the present disclosure.

[0249] On screen 801, instructions stored in memory (120) can cause the electronic device (100) to display a fourth image (810) on the display (140). The fourth image (810) can be displayed on an image editing interface.

[0250] For example, the fourth image (810) may include at least one object (811). The fourth image (810) may include a tree (811) as an object.

[0251] In screen 801, instructions stored in memory (120) can cause the electronic device (100) to recognize and classify at least one object (811) through segmentation in the fourth image (810).

[0252] In screen 801, instructions stored in memory (120) may cause the electronic device (100) to identify a deformable object and / or an interactable object among at least one object (811) detected in the fourth image (810).

[0253] In the 801 screen, the instructions stored in the memory (120) can cause the electronic device (100) to recognize the tree (811) in the fourth image (810) as a deformable object, but can also infer skeleton information of the deformable object.

[0254] On the 801 screen, the instructions stored in the memory (120) can cause the electronic device (100) to display a notification on the graphic object display icon (530) that the inferred skeleton inference is complete. For example, the notification that the inference is complete may include an action of highlighting the graphic object display icon (530).

[0255] However, it is not limited thereto, and in the 801 screen, the instructions stored in the memory (120) may cause the electronic device (100) to partially infer skeleton information of a deformable object or, if it is determined that skeleton information needs to be generated by the user, display a graphic object creation icon (830) on the display (140).

[0256] When receiving user input for the graphic object creation icon (830), on screen 802, instructions stored in memory (120) may cause the electronic device (100) to overlay skeleton information and / or graphic objects (820) on a deformable object (e.g., a tree (811)) based on the user input. The user input may be a drawing input.

[0257] On the 802 screen, instructions stored in memory (120) can cause the electronic device (100) to receive user input for a graphic object (820).

[0258] On the 803 screen, instructions stored in the memory (120) can cause the electronic device (100) to change the shape of the graphic object (820) according to user input.

[0259] On the screen 803, the instructions stored in the memory (120) can cause the electronic device (100) to move a link interface and / or a joint interface included in a graphic object (820). For example, the user input can include a drag input. The instructions stored in the memory (120), when executed by the processor (110), can cause the electronic device (100) to display the link interface and / or joint interface moved according to the user input on the display (140).

[0260] On the 803 screen, instructions stored in the memory (120) can provide a user interface that controls the variable position so that the electronic device (100) can move only within a movable area taking into account the characteristics of the current object (e.g., tree (811)).

[0261] On screen 804, instructions stored in memory (120) can cause the electronic device (100) to generate an image including a changed object (e.g., a tree (811)) based on the movement of a graphic object (820).

[0262] In one embodiment, skeleton information (or location, coordinate information) of a changed object (e.g., a tree (811)) may be stored in memory (120) as meta information.

[0263] On screen 804, instructions stored in memory (120) may cause the electronic device (100) to extract a prompt and generate an image including a changed object (e.g., a tree (811)) based on the extracted prompt and / or movement of the graphic object (520).

[0264] On the screen 804, the instructions stored in the memory (120) may cause the electronic device (100) to display a graphic object display icon (530) on the fourth image (810) in which the generated image or object is changed on the display (140). Upon receiving a user input to the graphic object display icon (530) or the graphic object icon (830), the instructions stored in the memory (120) may cause the electronic device (100) to redisplay the graphic object (520) on a deformable object (e.g., a tree (811)) and edit the fourth image (810). Alternatively, upon receiving a user input to the graphic object display icon (530) or the graphic object icon (830), the instructions stored in the memory (120) may cause the electronic device (100) to display the graphic object (820) on the original image (810). In one embodiment, the image containing the changed object and the original image may be stored in memory (120).

[0265] FIG. 9 is a drawing showing an image editing method of an electronic device (100) according to one embodiment of the present disclosure.

[0266] In screen 901, instructions stored in memory (120) can cause the electronic device (100) to display a fifth image (910) on the display (140). The fifth image (910) can be displayed on an image editing interface.

[0267] For example, the fifth image (910) may include at least one object (911). The fifth image (910) may include a person (911) as an object.

[0268] In screen 901, instructions stored in memory (120) can cause the electronic device (100) to recognize and classify at least one object (911) through segmentation in the fifth image (910).

[0269] In screen 901, instructions stored in memory (120) may cause the electronic device (100) to identify a deformable object and / or an interactable object among at least one object (911) detected in the fifth image (910).

[0270] In screen 902, instructions stored in memory (120) may cause the electronic device (100) to overlay a first graphic object (920) on a deformable object (e.g., a person (911)) and display it on the display (140).

[0271] In one embodiment, the first graphic object (910) may include a shape and a deformable joint (921) having a larger area than a deformable object (e.g., a person (911)).

[0272] In screen 903, instructions stored in memory (120) may cause the electronic device (100) to overlay a second graphic object (930) on a deformable object (e.g., a person (911)) and display it on the display (140).

[0273] In one embodiment, the second graphic object (930) may be displayed as an opaque overlay of a shape having the same area as the deformable object (e.g., the person (911)) on the deformable object (e.g., the person (911)).

[0274] On screen 904, instructions stored in memory (120) may cause the electronic device (100) to translucently overlay a third graphic object (940) on a deformable object (e.g., a person (911)) and display it on the display (140).

[0275] In one embodiment, the third graphic object (940) may be displayed as a shape having the same area as the deformable object (e.g., person (911)) overlaid on the deformable object (e.g., person (911)) in a translucent or transparent manner. The third graphic object (940) may include a transparent or translucent image, and the second graphic object (930) may include an opaque image.

[0276] On screen 905, instructions stored in memory (120) may cause the electronic device (100) to overlay a fourth graphic object (950) on a deformable object (e.g., a person (911)) and display it on the display (140).

[0277] In one embodiment, the fourth graphic object (950) may include a deformable joint (950) in a deformable object (e.g., a person (911)).

[0278] In one embodiment, an electronic device (100) includes a display (140), a memory (120) storing instructions, and a processor (110), the instructions, when executed by the processor (110), cause the electronic device (100) to: display an image including at least one object through the display (140); generate skeleton information based at least in part on a determination that the at least one object corresponds to a deformable object; display a graphical object corresponding to the skeleton information on the at least one object in the image through the display (140); display a modified graphical object through the display (140) such that at least a portion of the graphical object is changed based at least in part on a first user input; generate a prompt based on the modified graphical object and at least a portion of the image; and generate an artificial intelligence (AI) image based on the prompt using an artificial intelligence model.

[0279] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: identify a deformable object and an interactable object, and perform prompt generation based on the modified graphical object, at least one object, and at least a portion of the image, as at least part of the operation of generating skeleton information.

[0280] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: receive a second user input for moving at least one object before generating the prompt, and, in response to the second user input, change the position of a graphical object on the image.

[0281] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: identify, through scene analysis, a deformable object and other interactable objects based at least in part on the changed position of the graphical object; and generate a prompt based on at least a portion of the modified graphical object, other object, and image.

[0282] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: generate a graphical object on at least one object included in an image based on a third user input.

[0283] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: generate skeleton information based on drawing input, at least as part of the operation of generating skeleton information.

[0284] In one embodiment, a graphics object may include a plurality of link interfaces and at least one joint interface connecting the link interfaces.

[0285] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: change an angle between link interfaces in response to a first user input.

[0286] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: change the length of one of the link interfaces in response to a fourth user input.

[0287] In one embodiment, the instructions, when executed by the processor (110), may cause the electronic device (100) to: perform re-lighting to generate an AI image.

[0288] In one embodiment, a method for editing an image of an electronic device (100) may include: displaying an image including at least one object through a display (140); generating skeleton information based at least in part on a determination that the at least one object corresponds to a deformable object; displaying a graphical object corresponding to the skeleton information on at least one object on the image through the display (140); displaying a modified graphical object such that at least a portion of the graphical object is changed through the display (140), based at least in part on a first user input; generating a prompt based on the modified graphical object and at least a portion of the image; and generating an artificial intelligence (AI) image based on the prompt using an artificial intelligence model.

[0289] In one embodiment, a method of editing an image of an electronic device (100) may include, as at least part of an operation of generating skeleton information, an operation of identifying a deformable object and an interactable object, and an operation of generating a prompt based on a modified graphical object, at least one object, and at least a portion of an image.

[0290] In one embodiment, a method of editing an image of an electronic device (100) may include, prior to generating a prompt, receiving a second user input for moving at least one object, and, in response to the second user input, changing a position of a graphical object on the image.

[0291] In one embodiment, a method of editing an image of an electronic device (100) may include identifying a deformable object and other interactable objects through scene analysis, based at least in part on a changed position of a graphical object, and generating a prompt based on at least a portion of the modified graphical object, other objects, and image.

[0292] In one embodiment, a method for editing an image of an electronic device (100) may include an action of generating a graphic object for at least one object included in an image based on a third user input.

[0293] In one embodiment, a method of editing an image of an electronic device (100) may include, as at least part of an operation of generating skeleton information, an operation of generating skeleton information based on a drawing input.

[0294] In one embodiment, a method of editing an image of an electronic device (100) may include an operation of changing an angle between link interfaces in response to a first user input.

[0295] In one embodiment, the image editing method of the electronic device (100) may include an operation of changing the length of one of the link interfaces according to a fourth user input.

[0296] In one embodiment, the image editing method of the electronic device (100) may include an operation of performing re-lighting to generate an AI image.

[0297] Electronic devices according to various embodiments disclosed in the present disclosure may take various forms. Electronic devices may include, for example, portable communication devices (e.g., smartphones), computer devices, portable multimedia devices, portable medical devices, cameras, wearable devices, or home appliances. Electronic devices according to embodiments of the present disclosure are not limited to the aforementioned devices.

[0298] The various embodiments of the present disclosure and the terminology used therein are not intended to limit the technical features described in the present disclosure to specific embodiments, but should be understood to include various modifications, equivalents, or substitutes of the embodiments. In connection with the description of the drawings, similar reference numerals may be used for similar or related components. The singular form of a noun corresponding to an item may include one or more of the items, unless the context clearly indicates otherwise. In the present disclosure, each of the phrases "A or B," "at least one of A and B," "at least one of A or B," "A, B, or C," "at least one of A, B, and C," and "at least one of A, B, or C" can include any one of the items listed together in the corresponding phrase among the phrases, or all possible combinations thereof. Terms such as "first," "second," or "first" or "second" may be used merely to distinguish one component from another, and do not limit the components in any other respect (e.g., importance or order). When a component (e.g., a first component) is referred to as "coupled" or "connected" to another (e.g., a second component), with or without the terms "functionally" or "communicatively," it means that the component can be connected to the other component directly (e.g., wired), wirelessly, or through a third component.

[0299] The term "module" used in various embodiments of the present disclosure may include a unit implemented in hardware, software, or firmware, and may be used interchangeably with terms such as logic, logic block, component, or circuit. A module may be an integral component, or a minimum unit or part of such a component that performs one or more functions. For example, according to one embodiment, a module may be implemented in the form of an application-specific integrated circuit (ASIC).

[0300] Various embodiments of the present disclosure may be implemented as software (e.g., a program (140)) including one or more instructions stored in a storage medium (e.g., an internal memory (136) or an external memory (138)) readable by a machine (e.g., an electronic device (101)). For example, a processor (e.g., a processor (110)) of the machine (e.g., an electronic device (101)) may call at least one instruction among the one or more instructions stored from the storage medium and execute it. This enables the machine to operate to perform at least one function according to the at least one called instruction. The one or more instructions may include code generated by a compiler or code executable by an interpreter. The machine-readable storage medium may be provided in the form of a non-transitory storage medium. Here, 'non-transitory' simply means that the storage medium is a tangible device and does not contain signals (e.g., electromagnetic waves), and the term does not distinguish between cases where data is stored semi-permanently or temporarily on the storage medium.

[0301] According to one embodiment, the method according to various embodiments disclosed in the present disclosure may be provided as a computer program product. The computer program product may be traded between sellers and buyers as a product. The computer program product may be distributed in the form of a device-readable storage medium (e.g., compact disc read-only memory (CD-ROM)) or an application store (e.g., Play Store). TM ) or directly between two user devices (e.g., smart phones), online distribution (e.g., downloading or uploading). In the case of online distribution, at least a portion of the computer program product may be at least temporarily stored or temporarily created in a machine-readable storage medium, such as the memory of a manufacturer's server, an application store's server, or an intermediary server.

[0302] According to various embodiments, each component (e.g., a module or a program) of the above-described components may include one or more entities, and some of the entities may be separated and placed in other components. According to various embodiments, one or more components or operations of the aforementioned components may be omitted, or one or more other components or operations may be added. Alternatively or additionally, a plurality of components (e.g., a module or a program) may be integrated into a single component. In such a case, the integrated component may perform one or more functions of each of the plurality of components identically or similarly to those performed by the corresponding component among the plurality of components prior to the integration. According to various embodiments, the operations performed by a module, program, or other component may be executed sequentially, in parallel, iteratively, or heuristically, or one or more of the operations may be executed in a different order, omitted, or one or more other operations may be added.

Claims

1. In electronic devices, display; Memory that stores instructions; and Includes a processor, The above instructions, when executed by the processor, cause the electronic device to: Displaying an image containing at least one object through said display, Generating skeleton information based at least in part on a determination that at least one object corresponds to a deformable object; Displaying a graphical object corresponding to the skeleton information on at least one object on the image through the display; Displaying a modified graphic object such that at least a portion of the graphic object is changed through the display, based at least in part on a first user input; Generate a prompt based on at least part of the modified graphic object and image, An electronic device that generates an AI (artificial intelligence) image based on the above prompt using an artificial intelligence model.

2. In paragraph 1, The above instructions, when executed by the processor, cause the electronic device to: As at least part of the operation of generating the skeleton information, identifying an object that can interact with the deformable object, An electronic device that performs the prompt generation based on the modified graphic object, the at least one object, and at least a portion of the image.

3. In paragraph 2, The above instructions, when executed by the processor, cause the electronic device to: Before performing the generation of the above prompt, receiving a second user input for moving at least one object, In response to the second user input, change the position of the graphic object on the image; Identifying other objects that can interact with the deformable object through scene analysis, at least in part based on the changed position of the graphic object; An electronic device that performs the prompt generation based on the modified graphic object, the other object, and at least a portion of the image.

4. In paragraph 1, The above instructions, when executed by the processor, cause the electronic device to: An electronic device that generates a graphic object for at least one object included in the image based on a third user input.

5. In paragraph 1, The above instructions, when executed by the processor, cause the electronic device to: An electronic device that generates the skeleton information based on a drawing input, at least as a part of the operation of generating the skeleton information.

6. In paragraph 1, The above graphic object is An electronic device comprising a plurality of link interfaces and at least one joint interface connecting the link interfaces.

7. In paragraph 6, The above instructions, when executed by the processor, cause the electronic device to: Change the angle between the link interfaces according to the first user input, An electronic device that changes the length of one of the link interfaces according to a fourth user input.

8. In paragraph 1, The above instructions, when executed by the processor, cause the electronic device to: An electronic device that performs re-lighting to generate the AI image.

9. In a method for editing an image of an electronic device, An act of displaying an image containing at least one object; An operation of generating skeleton information based at least in part on a determination that at least one object corresponds to a deformable object; An action of displaying a graphical object corresponding to the skeleton information on at least one object on the image through the display; An action of displaying a modified graphical object through said display, wherein at least a portion of said graphical object is changed, based at least in part on a first user input; An action to generate a prompt based on at least a portion of the modified graphic object and image; and A method comprising an action of generating an AI (artificial intelligence) image based on the above prompt using an artificial intelligence model.

10. In paragraph 9, As at least part of the operation of generating the skeleton information, an operation of identifying an object that can interact with the deformable object; and A method further comprising generating the prompt based on the modified graphic object, the at least one object, and at least a portion of the image.

11. In paragraph 10, Before performing the generation of the above prompt, an action of receiving a second user input for moving the at least one object; An action of changing the position of the graphic object on the image in response to the second user input; An operation of identifying another object that can interact with the deformable object through scene analysis, based at least in part on the changed position of the graphic object; and A method further comprising generating the prompt based on at least a portion of the modified graphic object, the other object, and the image.

12. In paragraph 9, A method further comprising the action of generating said graphic object for said at least one object included in said image based on a third user input.

13. In paragraph 9, A method further comprising, as at least a part of the operation of generating the skeleton information, an operation of generating the skeleton information based on a drawing input.

14. In paragraph 9, The above graphic object is comprising a plurality of link interfaces and at least one joint interface connecting between the link interfaces; An operation of changing the angle between the link interfaces according to the first user input; and A method further comprising an action of changing the length of one of the link interfaces according to a fourth user input.

15. In paragraph 9, A method further comprising performing an action of generating said AI image by performing re-lighting.

Images